forked from gcdsfh/PMDT
gcdsfh145
74083 lines
2.5 MiB
Plaintext
Executable File
74083 lines
2.5 MiB
Plaintext
Executable File
//PUBGM(0.13.5)32位SDK
|
|
//作者:清华
|
|
//Telegram:@qinghuanb666
|
|
//生成时间:Fri Apr 18 20:44:39 2025
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------
|
|
//Functions
|
|
//---------------------------------------------------------------------------
|
|
|
|
// Function Engine.Actor.WasRecentlyRendered
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Tolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::WasRecentlyRendered(float Tolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.WasRecentlyRendered");
|
|
|
|
AActor_WasRecentlyRendered_Params params;
|
|
params.Tolerance = Tolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.UserConstructionScript
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void AActor::UserConstructionScript()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.UserConstructionScript");
|
|
|
|
AActor_UserConstructionScript_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.TearOff
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AActor::TearOff()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.TearOff");
|
|
|
|
AActor_TearOff_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SnapRootComponentTo
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* InParentActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SnapRootComponentTo(class AActor* InParentActor, const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SnapRootComponentTo");
|
|
|
|
AActor_SnapRootComponentTo_Params params;
|
|
params.InParentActor = InParentActor;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetTickGroup
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ETickingGroup> NewTickGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetTickGroup(TEnumAsByte<ETickingGroup> NewTickGroup)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetTickGroup");
|
|
|
|
AActor_SetTickGroup_Params params;
|
|
params.NewTickGroup = NewTickGroup;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetTickableWhenPaused
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bTickableWhenPaused (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetTickableWhenPaused(bool bTickableWhenPaused)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetTickableWhenPaused");
|
|
|
|
AActor_SetTickableWhenPaused_Params params;
|
|
params.bTickableWhenPaused = bTickableWhenPaused;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetReplicates
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInReplicates (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetReplicates(bool bInReplicates)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetReplicates");
|
|
|
|
AActor_SetReplicates_Params params;
|
|
params.bInReplicates = bInReplicates;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetReplicateMovement
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInReplicateMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetReplicateMovement(bool bInReplicateMovement)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetReplicateMovement");
|
|
|
|
AActor_SetReplicateMovement_Params params;
|
|
params.bInReplicateMovement = bInReplicateMovement;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetOwner
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* NewOwner (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetOwner(class AActor* NewOwner)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetOwner");
|
|
|
|
AActor_SetOwner_Params params;
|
|
params.NewOwner = NewOwner;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetNetDormancy
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ENetDormancy> NewDormancy (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetNetDormancy(TEnumAsByte<ENetDormancy> NewDormancy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetNetDormancy");
|
|
|
|
AActor_SetNetDormancy_Params params;
|
|
params.NewDormancy = NewDormancy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetLifeSpan
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InLifespan (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetLifeSpan(float InLifespan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetLifeSpan");
|
|
|
|
AActor_SetLifeSpan_Params params;
|
|
params.InLifespan = InLifespan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetActorTickInterval
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float TickInterval (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetActorTickInterval(float TickInterval)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetActorTickInterval");
|
|
|
|
AActor_SetActorTickInterval_Params params;
|
|
params.TickInterval = TickInterval;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetActorTickEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetActorTickEnabled(bool bEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetActorTickEnabled");
|
|
|
|
AActor_SetActorTickEnabled_Params params;
|
|
params.bEnabled = bEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetActorScale3D
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewScale3D (Parm, IsPlainOldData)
|
|
|
|
void AActor::SetActorScale3D(const struct FVector& NewScale3D)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetActorScale3D");
|
|
|
|
AActor_SetActorScale3D_Params params;
|
|
params.NewScale3D = NewScale3D;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetActorRelativeScale3D
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewRelativeScale (Parm, IsPlainOldData)
|
|
|
|
void AActor::SetActorRelativeScale3D(const struct FVector& NewRelativeScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetActorRelativeScale3D");
|
|
|
|
AActor_SetActorRelativeScale3D_Params params;
|
|
params.NewRelativeScale = NewRelativeScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetActorHiddenInGame
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewHidden (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetActorHiddenInGame(bool bNewHidden)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetActorHiddenInGame");
|
|
|
|
AActor_SetActorHiddenInGame_Params params;
|
|
params.bNewHidden = bNewHidden;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.SetActorEnableCollision
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewActorEnableCollision (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::SetActorEnableCollision(bool bNewActorEnableCollision)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.SetActorEnableCollision");
|
|
|
|
AActor_SetActorEnableCollision_Params params;
|
|
params.bNewActorEnableCollision = bNewActorEnableCollision;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.RemoveTickPrerequisiteComponent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UActorComponent* PrerequisiteComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void AActor::RemoveTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.RemoveTickPrerequisiteComponent");
|
|
|
|
AActor_RemoveTickPrerequisiteComponent_Params params;
|
|
params.PrerequisiteComponent = PrerequisiteComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.RemoveTickPrerequisiteActor
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* PrerequisiteActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::RemoveTickPrerequisiteActor(class AActor* PrerequisiteActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.RemoveTickPrerequisiteActor");
|
|
|
|
AActor_RemoveTickPrerequisiteActor_Params params;
|
|
params.PrerequisiteActor = PrerequisiteActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveTick
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaSeconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveTick(float DeltaSeconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveTick");
|
|
|
|
AActor_ReceiveTick_Params params;
|
|
params.DeltaSeconds = DeltaSeconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveRadialDamage
|
|
// (BlueprintAuthorityOnly, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// float DamageReceived (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDamageType* DamageType (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (Parm, IsPlainOldData)
|
|
// struct FHitResult HitInfo (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class AController* InstigatedBy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveRadialDamage(float DamageReceived, class UDamageType* DamageType, const struct FVector& Origin, const struct FHitResult& HitInfo, class AController* InstigatedBy, class AActor* DamageCauser)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveRadialDamage");
|
|
|
|
AActor_ReceiveRadialDamage_Params params;
|
|
params.DamageReceived = DamageReceived;
|
|
params.DamageType = DamageType;
|
|
params.Origin = Origin;
|
|
params.HitInfo = HitInfo;
|
|
params.InstigatedBy = InstigatedBy;
|
|
params.DamageCauser = DamageCauser;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceivePointDamage
|
|
// (BlueprintAuthorityOnly, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// float Damage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDamageType* DamageType (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector HitLocation (Parm, IsPlainOldData)
|
|
// struct FVector HitNormal (Parm, IsPlainOldData)
|
|
// class UPrimitiveComponent* HitComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ShotFromDirection (Parm, IsPlainOldData)
|
|
// class AController* InstigatedBy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitInfo (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void AActor::ReceivePointDamage(float Damage, class UDamageType* DamageType, const struct FVector& HitLocation, const struct FVector& HitNormal, class UPrimitiveComponent* HitComponent, const struct FName& BoneName, const struct FVector& ShotFromDirection, class AController* InstigatedBy, class AActor* DamageCauser, const struct FHitResult& HitInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceivePointDamage");
|
|
|
|
AActor_ReceivePointDamage_Params params;
|
|
params.Damage = Damage;
|
|
params.DamageType = DamageType;
|
|
params.HitLocation = HitLocation;
|
|
params.HitNormal = HitNormal;
|
|
params.HitComponent = HitComponent;
|
|
params.BoneName = BoneName;
|
|
params.ShotFromDirection = ShotFromDirection;
|
|
params.InstigatedBy = InstigatedBy;
|
|
params.DamageCauser = DamageCauser;
|
|
params.HitInfo = HitInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveHit
|
|
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* MyComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class AActor* Other (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* OtherComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool bSelfMoved (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector HitLocation (Parm, IsPlainOldData)
|
|
// struct FVector HitNormal (Parm, IsPlainOldData)
|
|
// struct FVector NormalImpulse (Parm, IsPlainOldData)
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void AActor::ReceiveHit(class UPrimitiveComponent* MyComp, class AActor* Other, class UPrimitiveComponent* OtherComp, bool bSelfMoved, const struct FVector& HitLocation, const struct FVector& HitNormal, const struct FVector& NormalImpulse, const struct FHitResult& Hit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveHit");
|
|
|
|
AActor_ReceiveHit_Params params;
|
|
params.MyComp = MyComp;
|
|
params.Other = Other;
|
|
params.OtherComp = OtherComp;
|
|
params.bSelfMoved = bSelfMoved;
|
|
params.HitLocation = HitLocation;
|
|
params.HitNormal = HitNormal;
|
|
params.NormalImpulse = NormalImpulse;
|
|
params.Hit = Hit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveEndPlay
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<EEndPlayReason> EndPlayReason (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveEndPlay(TEnumAsByte<EEndPlayReason> EndPlayReason)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveEndPlay");
|
|
|
|
AActor_ReceiveEndPlay_Params params;
|
|
params.EndPlayReason = EndPlayReason;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveDestroyed
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void AActor::ReceiveDestroyed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveDestroyed");
|
|
|
|
AActor_ReceiveDestroyed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveBeginPlay
|
|
// (Event, Protected, BlueprintEvent)
|
|
|
|
void AActor::ReceiveBeginPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveBeginPlay");
|
|
|
|
AActor_ReceiveBeginPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveAnyDamage
|
|
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float Damage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDamageType* DamageType (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AController* InstigatedBy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveAnyDamage(float Damage, class UDamageType* DamageType, class AController* InstigatedBy, class AActor* DamageCauser)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveAnyDamage");
|
|
|
|
AActor_ReceiveAnyDamage_Params params;
|
|
params.Damage = Damage;
|
|
params.DamageType = DamageType;
|
|
params.InstigatedBy = InstigatedBy;
|
|
params.DamageCauser = DamageCauser;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorOnReleased
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FKey ButtonReleased (Parm)
|
|
|
|
void AActor::ReceiveActorOnReleased(const struct FKey& ButtonReleased)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorOnReleased");
|
|
|
|
AActor_ReceiveActorOnReleased_Params params;
|
|
params.ButtonReleased = ButtonReleased;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorOnInputTouchLeave
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveActorOnInputTouchLeave(TEnumAsByte<ETouchIndex> FingerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorOnInputTouchLeave");
|
|
|
|
AActor_ReceiveActorOnInputTouchLeave_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorOnInputTouchEnter
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveActorOnInputTouchEnter(TEnumAsByte<ETouchIndex> FingerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorOnInputTouchEnter");
|
|
|
|
AActor_ReceiveActorOnInputTouchEnter_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorOnInputTouchEnd
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveActorOnInputTouchEnd(TEnumAsByte<ETouchIndex> FingerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorOnInputTouchEnd");
|
|
|
|
AActor_ReceiveActorOnInputTouchEnd_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorOnInputTouchBegin
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveActorOnInputTouchBegin(TEnumAsByte<ETouchIndex> FingerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorOnInputTouchBegin");
|
|
|
|
AActor_ReceiveActorOnInputTouchBegin_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorOnClicked
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FKey ButtonPressed (Parm)
|
|
|
|
void AActor::ReceiveActorOnClicked(const struct FKey& ButtonPressed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorOnClicked");
|
|
|
|
AActor_ReceiveActorOnClicked_Params params;
|
|
params.ButtonPressed = ButtonPressed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorEndOverlap
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* OtherActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveActorEndOverlap(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorEndOverlap");
|
|
|
|
AActor_ReceiveActorEndOverlap_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorEndCursorOver
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void AActor::ReceiveActorEndCursorOver()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorEndCursorOver");
|
|
|
|
AActor_ReceiveActorEndCursorOver_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorBeginOverlap
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* OtherActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::ReceiveActorBeginOverlap(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorBeginOverlap");
|
|
|
|
AActor_ReceiveActorBeginOverlap_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ReceiveActorBeginCursorOver
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void AActor::ReceiveActorBeginCursorOver()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ReceiveActorBeginCursorOver");
|
|
|
|
AActor_ReceiveActorBeginCursorOver_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.PrestreamTextures
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Seconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableStreaming (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int CinematicTextureGroups (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::PrestreamTextures(float Seconds, bool bEnableStreaming, int CinematicTextureGroups)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.PrestreamTextures");
|
|
|
|
AActor_PrestreamTextures_Params params;
|
|
params.Seconds = Seconds;
|
|
params.bEnableStreaming = bEnableStreaming;
|
|
params.CinematicTextureGroups = CinematicTextureGroups;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.OnRep_ReplicateMovement
|
|
// (Native, Public)
|
|
|
|
void AActor::OnRep_ReplicateMovement()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.OnRep_ReplicateMovement");
|
|
|
|
AActor_OnRep_ReplicateMovement_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.OnRep_ReplicatedMovement
|
|
// (Native, Public)
|
|
|
|
void AActor::OnRep_ReplicatedMovement()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.OnRep_ReplicatedMovement");
|
|
|
|
AActor_OnRep_ReplicatedMovement_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.OnRep_Owner
|
|
// (Native, Protected)
|
|
|
|
void AActor::OnRep_Owner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.OnRep_Owner");
|
|
|
|
AActor_OnRep_Owner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.OnRep_Instigator
|
|
// (Native, Public)
|
|
|
|
void AActor::OnRep_Instigator()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.OnRep_Instigator");
|
|
|
|
AActor_OnRep_Instigator_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.OnRep_AttachmentReplication
|
|
// (Native, Public)
|
|
|
|
void AActor::OnRep_AttachmentReplication()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.OnRep_AttachmentReplication");
|
|
|
|
AActor_OnRep_AttachmentReplication_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.MakeNoise
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float Loudness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APawn* NoiseInstigator (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NoiseLocation (Parm, IsPlainOldData)
|
|
// float MaxRange (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::MakeNoise(float Loudness, class APawn* NoiseInstigator, const struct FVector& NoiseLocation, float MaxRange, const struct FName& Tag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.MakeNoise");
|
|
|
|
AActor_MakeNoise_Params params;
|
|
params.Loudness = Loudness;
|
|
params.NoiseInstigator = NoiseInstigator;
|
|
params.NoiseLocation = NoiseLocation;
|
|
params.MaxRange = MaxRange;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.MakeMIDForMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Parent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* AActor::MakeMIDForMaterial(class UMaterialInterface* Parent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.MakeMIDForMaterial");
|
|
|
|
AActor_MakeMIDForMaterial_Params params;
|
|
params.Parent = Parent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_TeleportTo
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector DestLocation (Parm, IsPlainOldData)
|
|
// struct FRotator DestRotation (Parm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::K2_TeleportTo(const struct FVector& DestLocation, const struct FRotator& DestRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_TeleportTo");
|
|
|
|
AActor_K2_TeleportTo_Params params;
|
|
params.DestLocation = DestLocation;
|
|
params.DestRotation = DestRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform NewTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::K2_SetActorTransform(const struct FTransform& NewTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorTransform");
|
|
|
|
AActor_K2_SetActorTransform_Params params;
|
|
params.NewTransform = NewTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bTeleportPhysics (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::K2_SetActorRotation(const struct FRotator& NewRotation, bool bTeleportPhysics)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorRotation");
|
|
|
|
AActor_K2_SetActorRotation_Params params;
|
|
params.NewRotation = NewRotation;
|
|
params.bTeleportPhysics = bTeleportPhysics;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorRelativeTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform NewRelativeTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_SetActorRelativeTransform(const struct FTransform& NewRelativeTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorRelativeTransform");
|
|
|
|
AActor_K2_SetActorRelativeTransform_Params params;
|
|
params.NewRelativeTransform = NewRelativeTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorRelativeRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator NewRelativeRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_SetActorRelativeRotation(const struct FRotator& NewRelativeRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorRelativeRotation");
|
|
|
|
AActor_K2_SetActorRelativeRotation_Params params;
|
|
params.NewRelativeRotation = NewRelativeRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorRelativeLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewRelativeLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_SetActorRelativeLocation(const struct FVector& NewRelativeLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorRelativeLocation");
|
|
|
|
AActor_K2_SetActorRelativeLocation_Params params;
|
|
params.NewRelativeLocation = NewRelativeLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorLocationAndRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::K2_SetActorLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorLocationAndRotation");
|
|
|
|
AActor_K2_SetActorLocationAndRotation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.NewRotation = NewRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_SetActorLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::K2_SetActorLocation(const struct FVector& NewLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_SetActorLocation");
|
|
|
|
AActor_K2_SetActorLocation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_OnReset
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void AActor::K2_OnReset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_OnReset");
|
|
|
|
AActor_K2_OnReset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_OnEndViewTarget
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* PC (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_OnEndViewTarget(class APlayerController* PC)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_OnEndViewTarget");
|
|
|
|
AActor_K2_OnEndViewTarget_Params params;
|
|
params.PC = PC;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_OnBecomeViewTarget
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* PC (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_OnBecomeViewTarget(class APlayerController* PC)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_OnBecomeViewTarget");
|
|
|
|
AActor_K2_OnBecomeViewTarget_Params params;
|
|
params.PC = PC;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_GetRootComponent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class USceneComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class USceneComponent* AActor::K2_GetRootComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_GetRootComponent");
|
|
|
|
AActor_K2_GetRootComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_GetActorRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator AActor::K2_GetActorRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_GetActorRotation");
|
|
|
|
AActor_K2_GetActorRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_GetActorLocation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::K2_GetActorLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_GetActorLocation");
|
|
|
|
AActor_K2_GetActorLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_DetachFromActor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EDetachmentRule LocationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EDetachmentRule RotationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EDetachmentRule ScaleRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_DetachFromActor(EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_DetachFromActor");
|
|
|
|
AActor_K2_DetachFromActor_Params params;
|
|
params.LocationRule = LocationRule;
|
|
params.RotationRule = RotationRule;
|
|
params.ScaleRule = ScaleRule;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_DestroyComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UActorComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void AActor::K2_DestroyComponent(class UActorComponent* Component)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_DestroyComponent");
|
|
|
|
AActor_K2_DestroyComponent_Params params;
|
|
params.Component = Component;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_DestroyActor
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AActor::K2_DestroyActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_DestroyActor");
|
|
|
|
AActor_K2_DestroyActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AttachToComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* Parent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName SocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule LocationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule RotationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule ScaleRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bWeldSimulatedBodies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AttachToComponent(class USceneComponent* Parent, const struct FName& SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AttachToComponent");
|
|
|
|
AActor_K2_AttachToComponent_Params params;
|
|
params.Parent = Parent;
|
|
params.SocketName = SocketName;
|
|
params.LocationRule = LocationRule;
|
|
params.RotationRule = RotationRule;
|
|
params.ScaleRule = ScaleRule;
|
|
params.bWeldSimulatedBodies = bWeldSimulatedBodies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AttachToActor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* ParentActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule LocationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule RotationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule ScaleRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bWeldSimulatedBodies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AttachToActor(class AActor* ParentActor, const struct FName& SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AttachToActor");
|
|
|
|
AActor_K2_AttachToActor_Params params;
|
|
params.ParentActor = ParentActor;
|
|
params.SocketName = SocketName;
|
|
params.LocationRule = LocationRule;
|
|
params.RotationRule = RotationRule;
|
|
params.ScaleRule = ScaleRule;
|
|
params.bWeldSimulatedBodies = bWeldSimulatedBodies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AttachRootComponentToActor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* InParentActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> AttachLocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bWeldSimulatedBodies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AttachRootComponentToActor(class AActor* InParentActor, const struct FName& InSocketName, TEnumAsByte<EAttachLocation> AttachLocationType, bool bWeldSimulatedBodies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AttachRootComponentToActor");
|
|
|
|
AActor_K2_AttachRootComponentToActor_Params params;
|
|
params.InParentActor = InParentActor;
|
|
params.InSocketName = InSocketName;
|
|
params.AttachLocationType = AttachLocationType;
|
|
params.bWeldSimulatedBodies = bWeldSimulatedBodies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AttachRootComponentTo
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* InParent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> AttachLocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bWeldSimulatedBodies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AttachRootComponentTo(class USceneComponent* InParent, const struct FName& InSocketName, TEnumAsByte<EAttachLocation> AttachLocationType, bool bWeldSimulatedBodies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AttachRootComponentTo");
|
|
|
|
AActor_K2_AttachRootComponentTo_Params params;
|
|
params.InParent = InParent;
|
|
params.InSocketName = InSocketName;
|
|
params.AttachLocationType = AttachLocationType;
|
|
params.bWeldSimulatedBodies = bWeldSimulatedBodies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AddActorWorldTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform DeltaTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AddActorWorldTransform(const struct FTransform& DeltaTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AddActorWorldTransform");
|
|
|
|
AActor_K2_AddActorWorldTransform_Params params;
|
|
params.DeltaTransform = DeltaTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AddActorWorldRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator DeltaRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AddActorWorldRotation(const struct FRotator& DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AddActorWorldRotation");
|
|
|
|
AActor_K2_AddActorWorldRotation_Params params;
|
|
params.DeltaRotation = DeltaRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AddActorWorldOffset
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector DeltaLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AddActorWorldOffset(const struct FVector& DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AddActorWorldOffset");
|
|
|
|
AActor_K2_AddActorWorldOffset_Params params;
|
|
params.DeltaLocation = DeltaLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AddActorLocalTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform NewTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AddActorLocalTransform(const struct FTransform& NewTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AddActorLocalTransform");
|
|
|
|
AActor_K2_AddActorLocalTransform_Params params;
|
|
params.NewTransform = NewTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AddActorLocalRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator DeltaRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AddActorLocalRotation(const struct FRotator& DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AddActorLocalRotation");
|
|
|
|
AActor_K2_AddActorLocalRotation_Params params;
|
|
params.DeltaRotation = DeltaRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.K2_AddActorLocalOffset
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector DeltaLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::K2_AddActorLocalOffset(const struct FVector& DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.K2_AddActorLocalOffset");
|
|
|
|
AActor_K2_AddActorLocalOffset_Params params;
|
|
params.DeltaLocation = DeltaLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.IsOverlappingActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* Other (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::IsOverlappingActor(class AActor* Other)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.IsOverlappingActor");
|
|
|
|
AActor_IsOverlappingActor_Params params;
|
|
params.Other = Other;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.IsChildActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::IsChildActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.IsChildActor");
|
|
|
|
AActor_IsChildActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.IsActorTickEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::IsActorTickEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.IsActorTickEnabled");
|
|
|
|
AActor_IsActorTickEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.IsActorBeingDestroyed
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::IsActorBeingDestroyed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.IsActorBeingDestroyed");
|
|
|
|
AActor_IsActorBeingDestroyed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.HasAuthority
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::HasAuthority()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.HasAuthority");
|
|
|
|
AActor_HasAuthority_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetVerticalDistanceTo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* OtherActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetVerticalDistanceTo(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetVerticalDistanceTo");
|
|
|
|
AActor_GetVerticalDistanceTo_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetVelocity
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetVelocity()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetVelocity");
|
|
|
|
AActor_GetVelocity_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetTransform
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform AActor::GetTransform()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetTransform");
|
|
|
|
AActor_GetTransform_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetTickableWhenPaused
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::GetTickableWhenPaused()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetTickableWhenPaused");
|
|
|
|
AActor_GetTickableWhenPaused_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetSquaredDistanceTo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* OtherActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetSquaredDistanceTo(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetSquaredDistanceTo");
|
|
|
|
AActor_GetSquaredDistanceTo_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetRemoteRole
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ENetRole> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ENetRole> AActor::GetRemoteRole()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetRemoteRole");
|
|
|
|
AActor_GetRemoteRole_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetParentComponent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UChildActorComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UChildActorComponent* AActor::GetParentComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetParentComponent");
|
|
|
|
AActor_GetParentComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetParentActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AActor::GetParentActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetParentActor");
|
|
|
|
AActor_GetParentActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetOwner
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AActor::GetOwner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetOwner");
|
|
|
|
AActor_GetOwner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetOverlappingComponents
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class UPrimitiveComponent*> OverlappingComponents (Parm, OutParm, ZeroConstructor)
|
|
|
|
void AActor::GetOverlappingComponents(TArray<class UPrimitiveComponent*>* OverlappingComponents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetOverlappingComponents");
|
|
|
|
AActor_GetOverlappingComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OverlappingComponents != nullptr)
|
|
*OverlappingComponents = params.OverlappingComponents;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetOverlappingActors
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class AActor*> OverlappingActors (Parm, OutParm, ZeroConstructor)
|
|
// class UClass* ClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::GetOverlappingActors(class UClass* ClassFilter, TArray<class AActor*>* OverlappingActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetOverlappingActors");
|
|
|
|
AActor_GetOverlappingActors_Params params;
|
|
params.ClassFilter = ClassFilter;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OverlappingActors != nullptr)
|
|
*OverlappingActors = params.OverlappingActors;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetLifeSpan
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetLifeSpan()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetLifeSpan");
|
|
|
|
AActor_GetLifeSpan_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetInstigatorController
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AController* AActor::GetInstigatorController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetInstigatorController");
|
|
|
|
AActor_GetInstigatorController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetInstigator
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* AActor::GetInstigator()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetInstigator");
|
|
|
|
AActor_GetInstigator_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetInputVectorAxisValue
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey InputAxisKey (ConstParm, Parm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetInputVectorAxisValue(const struct FKey& InputAxisKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetInputVectorAxisValue");
|
|
|
|
AActor_GetInputVectorAxisValue_Params params;
|
|
params.InputAxisKey = InputAxisKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetInputAxisValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InputAxisName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetInputAxisValue(const struct FName& InputAxisName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetInputAxisValue");
|
|
|
|
AActor_GetInputAxisValue_Params params;
|
|
params.InputAxisName = InputAxisName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetInputAxisKeyValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey InputAxisKey (ConstParm, Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetInputAxisKeyValue(const struct FKey& InputAxisKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetInputAxisKeyValue");
|
|
|
|
AActor_GetInputAxisKeyValue_Params params;
|
|
params.InputAxisKey = InputAxisKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetHorizontalDotProductTo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* OtherActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetHorizontalDotProductTo(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetHorizontalDotProductTo");
|
|
|
|
AActor_GetHorizontalDotProductTo_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetHorizontalDistanceTo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* OtherActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetHorizontalDistanceTo(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetHorizontalDistanceTo");
|
|
|
|
AActor_GetHorizontalDistanceTo_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetGameTimeSinceCreation
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetGameTimeSinceCreation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetGameTimeSinceCreation");
|
|
|
|
AActor_GetGameTimeSinceCreation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetDotProductTo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* OtherActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetDotProductTo(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetDotProductTo");
|
|
|
|
AActor_GetDotProductTo_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetDistanceTo
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* OtherActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetDistanceTo(class AActor* OtherActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetDistanceTo");
|
|
|
|
AActor_GetDistanceTo_Params params;
|
|
params.OtherActor = OtherActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetComponentsByTag
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UClass* ComponentClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class UActorComponent*> ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<class UActorComponent*> AActor::GetComponentsByTag(class UClass* ComponentClass, const struct FName& Tag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetComponentsByTag");
|
|
|
|
AActor_GetComponentsByTag_Params params;
|
|
params.ComponentClass = ComponentClass;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetComponentsByClass
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UClass* ComponentClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class UActorComponent*> ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<class UActorComponent*> AActor::GetComponentsByClass(class UClass* ComponentClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetComponentsByClass");
|
|
|
|
AActor_GetComponentsByClass_Params params;
|
|
params.ComponentClass = ComponentClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetComponentByClass
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UClass* ComponentClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UActorComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UActorComponent* AActor::GetComponentByClass(class UClass* ComponentClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetComponentByClass");
|
|
|
|
AActor_GetComponentByClass_Params params;
|
|
params.ComponentClass = ComponentClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetAttachParentSocketName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName AActor::GetAttachParentSocketName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetAttachParentSocketName");
|
|
|
|
AActor_GetAttachParentSocketName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetAttachParentActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AActor::GetAttachParentActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetAttachParentActor");
|
|
|
|
AActor_GetAttachParentActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetAttachedActors
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
|
|
void AActor::GetAttachedActors(TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetAttachedActors");
|
|
|
|
AActor_GetAttachedActors_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetAllChildActors
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class AActor*> ChildActors (Parm, OutParm, ZeroConstructor)
|
|
// bool bIncludeDescendants (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::GetAllChildActors(bool bIncludeDescendants, TArray<class AActor*>* ChildActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetAllChildActors");
|
|
|
|
AActor_GetAllChildActors_Params params;
|
|
params.bIncludeDescendants = bIncludeDescendants;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ChildActors != nullptr)
|
|
*ChildActors = params.ChildActors;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorUpVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetActorUpVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorUpVector");
|
|
|
|
AActor_GetActorUpVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorTimeDilation
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetActorTimeDilation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorTimeDilation");
|
|
|
|
AActor_GetActorTimeDilation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorTickInterval
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AActor::GetActorTickInterval()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorTickInterval");
|
|
|
|
AActor_GetActorTickInterval_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorScale3D
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetActorScale3D()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorScale3D");
|
|
|
|
AActor_GetActorScale3D_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorRightVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetActorRightVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorRightVector");
|
|
|
|
AActor_GetActorRightVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorRelativeScale3D
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetActorRelativeScale3D()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorRelativeScale3D");
|
|
|
|
AActor_GetActorRelativeScale3D_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorForwardVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AActor::GetActorForwardVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorForwardVector");
|
|
|
|
AActor_GetActorForwardVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorEyesViewPoint
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector OutLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator OutRotation (Parm, OutParm, IsPlainOldData)
|
|
|
|
void AActor::GetActorEyesViewPoint(struct FVector* OutLocation, struct FRotator* OutRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorEyesViewPoint");
|
|
|
|
AActor_GetActorEyesViewPoint_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutLocation != nullptr)
|
|
*OutLocation = params.OutLocation;
|
|
if (OutRotation != nullptr)
|
|
*OutRotation = params.OutRotation;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorEnableCollision
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::GetActorEnableCollision()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorEnableCollision");
|
|
|
|
AActor_GetActorEnableCollision_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.GetActorBounds
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool bOnlyCollidingComponents (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, OutParm, IsPlainOldData)
|
|
|
|
void AActor::GetActorBounds(bool bOnlyCollidingComponents, struct FVector* Origin, struct FVector* BoxExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.GetActorBounds");
|
|
|
|
AActor_GetActorBounds_Params params;
|
|
params.bOnlyCollidingComponents = bOnlyCollidingComponents;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Origin != nullptr)
|
|
*Origin = params.Origin;
|
|
if (BoxExtent != nullptr)
|
|
*BoxExtent = params.BoxExtent;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ForceNetUpdate
|
|
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
|
|
void AActor::ForceNetUpdate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ForceNetUpdate");
|
|
|
|
AActor_ForceNetUpdate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ForceNetConsider
|
|
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
|
|
void AActor::ForceNetConsider()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ForceNetConsider");
|
|
|
|
AActor_ForceNetConsider_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.FlushNetDormancy
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
|
|
void AActor::FlushNetDormancy()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.FlushNetDormancy");
|
|
|
|
AActor_FlushNetDormancy_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.EnableInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::EnableInput(class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.EnableInput");
|
|
|
|
AActor_EnableInput_Params params;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.DisableInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* PlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::DisableInput(class APlayerController* PlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.DisableInput");
|
|
|
|
AActor_DisableInput_Params params;
|
|
params.PlayerController = PlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.DetachRootComponentFromParent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bMaintainWorldPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::DetachRootComponentFromParent(bool bMaintainWorldPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.DetachRootComponentFromParent");
|
|
|
|
AActor_DetachRootComponentFromParent_Params params;
|
|
params.bMaintainWorldPosition = bMaintainWorldPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.AddTickPrerequisiteComponent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UActorComponent* PrerequisiteComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void AActor::AddTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.AddTickPrerequisiteComponent");
|
|
|
|
AActor_AddTickPrerequisiteComponent_Params params;
|
|
params.PrerequisiteComponent = PrerequisiteComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.AddTickPrerequisiteActor
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* PrerequisiteActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AActor::AddTickPrerequisiteActor(class AActor* PrerequisiteActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.AddTickPrerequisiteActor");
|
|
|
|
AActor_AddTickPrerequisiteActor_Params params;
|
|
params.PrerequisiteActor = PrerequisiteActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.AddComponent
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName TemplateName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bManualAttachment (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform RelativeTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class UObject* ComponentTemplateContext (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UActorComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UActorComponent* AActor::AddComponent(const struct FName& TemplateName, bool bManualAttachment, const struct FTransform& RelativeTransform, class UObject* ComponentTemplateContext)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.AddComponent");
|
|
|
|
AActor_AddComponent_Params params;
|
|
params.TemplateName = TemplateName;
|
|
params.bManualAttachment = bManualAttachment;
|
|
params.RelativeTransform = RelativeTransform;
|
|
params.ComponentTemplateContext = ComponentTemplateContext;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Actor.ActorHasTag
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AActor::ActorHasTag(const struct FName& Tag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Actor.ActorHasTag");
|
|
|
|
AActor_ActorHasTag_Params params;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.ToggleActive
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UActorComponent::ToggleActive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.ToggleActive");
|
|
|
|
UActorComponent_ToggleActive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetTickGroup
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ETickingGroup> NewTickGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetTickGroup(TEnumAsByte<ETickingGroup> NewTickGroup)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetTickGroup");
|
|
|
|
UActorComponent_SetTickGroup_Params params;
|
|
params.NewTickGroup = NewTickGroup;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetTickableWhenPaused
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bTickableWhenPaused (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetTickableWhenPaused(bool bTickableWhenPaused)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetTickableWhenPaused");
|
|
|
|
UActorComponent_SetTickableWhenPaused_Params params;
|
|
params.bTickableWhenPaused = bTickableWhenPaused;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetIsReplicated
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ShouldReplicate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetIsReplicated(bool ShouldReplicate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetIsReplicated");
|
|
|
|
UActorComponent_SetIsReplicated_Params params;
|
|
params.ShouldReplicate = ShouldReplicate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetComponentTickInterval
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float TickInterval (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetComponentTickInterval(float TickInterval)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetComponentTickInterval");
|
|
|
|
UActorComponent_SetComponentTickInterval_Params params;
|
|
params.TickInterval = TickInterval;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetComponentTickEnabled
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetComponentTickEnabled(bool bEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetComponentTickEnabled");
|
|
|
|
UActorComponent_SetComponentTickEnabled_Params params;
|
|
params.bEnabled = bEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetAutoActivate
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewAutoActivate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetAutoActivate(bool bNewAutoActivate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetAutoActivate");
|
|
|
|
UActorComponent_SetAutoActivate_Params params;
|
|
params.bNewAutoActivate = bNewAutoActivate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.SetActive
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewActive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bReset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::SetActive(bool bNewActive, bool bReset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.SetActive");
|
|
|
|
UActorComponent_SetActive_Params params;
|
|
params.bNewActive = bNewActive;
|
|
params.bReset = bReset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.RemoveTickPrerequisiteComponent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UActorComponent* PrerequisiteComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UActorComponent::RemoveTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.RemoveTickPrerequisiteComponent");
|
|
|
|
UActorComponent_RemoveTickPrerequisiteComponent_Params params;
|
|
params.PrerequisiteComponent = PrerequisiteComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.RemoveTickPrerequisiteActor
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* PrerequisiteActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::RemoveTickPrerequisiteActor(class AActor* PrerequisiteActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.RemoveTickPrerequisiteActor");
|
|
|
|
UActorComponent_RemoveTickPrerequisiteActor_Params params;
|
|
params.PrerequisiteActor = PrerequisiteActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.ReceiveTick
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaSeconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::ReceiveTick(float DeltaSeconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.ReceiveTick");
|
|
|
|
UActorComponent_ReceiveTick_Params params;
|
|
params.DeltaSeconds = DeltaSeconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.ReceiveEndPlay
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<EEndPlayReason> EndPlayReason (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::ReceiveEndPlay(TEnumAsByte<EEndPlayReason> EndPlayReason)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.ReceiveEndPlay");
|
|
|
|
UActorComponent_ReceiveEndPlay_Params params;
|
|
params.EndPlayReason = EndPlayReason;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.ReceiveBeginPlay
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UActorComponent::ReceiveBeginPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.ReceiveBeginPlay");
|
|
|
|
UActorComponent_ReceiveBeginPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.OnRep_IsActive
|
|
// (Final, Native, Public)
|
|
|
|
void UActorComponent::OnRep_IsActive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.OnRep_IsActive");
|
|
|
|
UActorComponent_OnRep_IsActive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.K2_DestroyComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::K2_DestroyComponent(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.K2_DestroyComponent");
|
|
|
|
UActorComponent_K2_DestroyComponent_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.IsComponentTickEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UActorComponent::IsComponentTickEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.IsComponentTickEnabled");
|
|
|
|
UActorComponent_IsComponentTickEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.IsBeingDestroyed
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UActorComponent::IsBeingDestroyed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.IsBeingDestroyed");
|
|
|
|
UActorComponent_IsBeingDestroyed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.IsActive
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UActorComponent::IsActive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.IsActive");
|
|
|
|
UActorComponent_IsActive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.GetOwner
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UActorComponent::GetOwner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.GetOwner");
|
|
|
|
UActorComponent_GetOwner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.GetComponentTickInterval
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UActorComponent::GetComponentTickInterval()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.GetComponentTickInterval");
|
|
|
|
UActorComponent_GetComponentTickInterval_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.ForceNetUpdate
|
|
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
|
|
void UActorComponent::ForceNetUpdate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.ForceNetUpdate");
|
|
|
|
UActorComponent_ForceNetUpdate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.Deactivate
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UActorComponent::Deactivate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.Deactivate");
|
|
|
|
UActorComponent_Deactivate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.ComponentHasTag
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UActorComponent::ComponentHasTag(const struct FName& Tag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.ComponentHasTag");
|
|
|
|
UActorComponent_ComponentHasTag_Params params;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.AddTickPrerequisiteComponent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UActorComponent* PrerequisiteComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UActorComponent::AddTickPrerequisiteComponent(class UActorComponent* PrerequisiteComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.AddTickPrerequisiteComponent");
|
|
|
|
UActorComponent_AddTickPrerequisiteComponent_Params params;
|
|
params.PrerequisiteComponent = PrerequisiteComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.AddTickPrerequisiteActor
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* PrerequisiteActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::AddTickPrerequisiteActor(class AActor* PrerequisiteActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.AddTickPrerequisiteActor");
|
|
|
|
UActorComponent_AddTickPrerequisiteActor_Params params;
|
|
params.PrerequisiteActor = PrerequisiteActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ActorComponent.Activate
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bReset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UActorComponent::Activate(bool bReset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ActorComponent.Activate");
|
|
|
|
UActorComponent_Activate_Params params;
|
|
params.bReset = bReset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.ToggleVisibility
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bPropagateToChildren (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::ToggleVisibility(bool bPropagateToChildren)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.ToggleVisibility");
|
|
|
|
USceneComponent_ToggleVisibility_Params params;
|
|
params.bPropagateToChildren = bPropagateToChildren;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.SnapTo
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* InParent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::SnapTo(class USceneComponent* InParent, const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.SnapTo");
|
|
|
|
USceneComponent_SnapTo_Params params;
|
|
params.InParent = InParent;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.SetWorldScale3D
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewScale (Parm, IsPlainOldData)
|
|
|
|
void USceneComponent::SetWorldScale3D(const struct FVector& NewScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.SetWorldScale3D");
|
|
|
|
USceneComponent_SetWorldScale3D_Params params;
|
|
params.NewScale = NewScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.SetVisibility
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewVisibility (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPropagateToChildren (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::SetVisibility(bool bNewVisibility, bool bPropagateToChildren)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.SetVisibility");
|
|
|
|
USceneComponent_SetVisibility_Params params;
|
|
params.bNewVisibility = bNewVisibility;
|
|
params.bPropagateToChildren = bPropagateToChildren;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.SetRelativeScale3D
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewScale3D (Parm, IsPlainOldData)
|
|
|
|
void USceneComponent::SetRelativeScale3D(const struct FVector& NewScale3D)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.SetRelativeScale3D");
|
|
|
|
USceneComponent_SetRelativeScale3D_Params params;
|
|
params.NewScale3D = NewScale3D;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.SetHiddenInGame
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewHidden (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPropagateToChildren (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::SetHiddenInGame(bool NewHidden, bool bPropagateToChildren)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.SetHiddenInGame");
|
|
|
|
USceneComponent_SetHiddenInGame_Params params;
|
|
params.NewHidden = NewHidden;
|
|
params.bPropagateToChildren = bPropagateToChildren;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.SetAbsolute
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewAbsoluteLocation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bNewAbsoluteRotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bNewAbsoluteScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::SetAbsolute(bool bNewAbsoluteLocation, bool bNewAbsoluteRotation, bool bNewAbsoluteScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.SetAbsolute");
|
|
|
|
USceneComponent_SetAbsolute_Params params;
|
|
params.bNewAbsoluteLocation = bNewAbsoluteLocation;
|
|
params.bNewAbsoluteRotation = bNewAbsoluteRotation;
|
|
params.bNewAbsoluteScale = bNewAbsoluteScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.ResetRelativeTransform
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USceneComponent::ResetRelativeTransform()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.ResetRelativeTransform");
|
|
|
|
USceneComponent_ResetRelativeTransform_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.OnRep_Visibility
|
|
// (Final, Native, Private)
|
|
// Parameters:
|
|
// bool OldValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::OnRep_Visibility(bool OldValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.OnRep_Visibility");
|
|
|
|
USceneComponent_OnRep_Visibility_Params params;
|
|
params.OldValue = OldValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.OnRep_Transform
|
|
// (Final, Native, Private)
|
|
|
|
void USceneComponent::OnRep_Transform()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.OnRep_Transform");
|
|
|
|
USceneComponent_OnRep_Transform_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.OnRep_AttachSocketName
|
|
// (Final, Native, Private)
|
|
|
|
void USceneComponent::OnRep_AttachSocketName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.OnRep_AttachSocketName");
|
|
|
|
USceneComponent_OnRep_AttachSocketName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.OnRep_AttachParent
|
|
// (Final, Native, Private)
|
|
|
|
void USceneComponent::OnRep_AttachParent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.OnRep_AttachParent");
|
|
|
|
USceneComponent_OnRep_AttachParent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.OnRep_AttachChildren
|
|
// (Final, Native, Private)
|
|
|
|
void USceneComponent::OnRep_AttachChildren()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.OnRep_AttachChildren");
|
|
|
|
USceneComponent_OnRep_AttachChildren_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetWorldTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform NewTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetWorldTransform(const struct FTransform& NewTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetWorldTransform");
|
|
|
|
USceneComponent_K2_SetWorldTransform_Params params;
|
|
params.NewTransform = NewTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetWorldRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetWorldRotation(const struct FRotator& NewRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetWorldRotation");
|
|
|
|
USceneComponent_K2_SetWorldRotation_Params params;
|
|
params.NewRotation = NewRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetWorldLocationAndRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetWorldLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetWorldLocationAndRotation");
|
|
|
|
USceneComponent_K2_SetWorldLocationAndRotation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.NewRotation = NewRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetWorldLocation(const struct FVector& NewLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetWorldLocation");
|
|
|
|
USceneComponent_K2_SetWorldLocation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetRelativeTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform NewTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetRelativeTransform(const struct FTransform& NewTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetRelativeTransform");
|
|
|
|
USceneComponent_K2_SetRelativeTransform_Params params;
|
|
params.NewTransform = NewTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetRelativeRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetRelativeRotation(const struct FRotator& NewRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetRelativeRotation");
|
|
|
|
USceneComponent_K2_SetRelativeRotation_Params params;
|
|
params.NewRotation = NewRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetRelativeLocationAndRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetRelativeLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetRelativeLocationAndRotation");
|
|
|
|
USceneComponent_K2_SetRelativeLocationAndRotation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.NewRotation = NewRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_SetRelativeLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_SetRelativeLocation(const struct FVector& NewLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_SetRelativeLocation");
|
|
|
|
USceneComponent_K2_SetRelativeLocation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_GetComponentToWorld
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USceneComponent::K2_GetComponentToWorld()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_GetComponentToWorld");
|
|
|
|
USceneComponent_K2_GetComponentToWorld_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_GetComponentScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::K2_GetComponentScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_GetComponentScale");
|
|
|
|
USceneComponent_K2_GetComponentScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_GetComponentRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USceneComponent::K2_GetComponentRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_GetComponentRotation");
|
|
|
|
USceneComponent_K2_GetComponentRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_GetComponentLocation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::K2_GetComponentLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_GetComponentLocation");
|
|
|
|
USceneComponent_K2_GetComponentLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_DetachFromComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EDetachmentRule LocationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EDetachmentRule RotationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EDetachmentRule ScaleRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bCallModify (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_DetachFromComponent(EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule, bool bCallModify)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_DetachFromComponent");
|
|
|
|
USceneComponent_K2_DetachFromComponent_Params params;
|
|
params.LocationRule = LocationRule;
|
|
params.RotationRule = RotationRule;
|
|
params.ScaleRule = ScaleRule;
|
|
params.bCallModify = bCallModify;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AttachToComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* Parent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName SocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule LocationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule RotationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule ScaleRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bWeldSimulatedBodies (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::K2_AttachToComponent(class USceneComponent* Parent, const struct FName& SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AttachToComponent");
|
|
|
|
USceneComponent_K2_AttachToComponent_Params params;
|
|
params.Parent = Parent;
|
|
params.SocketName = SocketName;
|
|
params.LocationRule = LocationRule;
|
|
params.RotationRule = RotationRule;
|
|
params.ScaleRule = ScaleRule;
|
|
params.bWeldSimulatedBodies = bWeldSimulatedBodies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AttachTo
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* InParent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> AttachType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bWeldSimulatedBodies (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::K2_AttachTo(class USceneComponent* InParent, const struct FName& InSocketName, TEnumAsByte<EAttachLocation> AttachType, bool bWeldSimulatedBodies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AttachTo");
|
|
|
|
USceneComponent_K2_AttachTo_Params params;
|
|
params.InParent = InParent;
|
|
params.InSocketName = InSocketName;
|
|
params.AttachType = AttachType;
|
|
params.bWeldSimulatedBodies = bWeldSimulatedBodies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddWorldTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform DeltaTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddWorldTransform(const struct FTransform& DeltaTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddWorldTransform");
|
|
|
|
USceneComponent_K2_AddWorldTransform_Params params;
|
|
params.DeltaTransform = DeltaTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddWorldRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator DeltaRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddWorldRotation(const struct FRotator& DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddWorldRotation");
|
|
|
|
USceneComponent_K2_AddWorldRotation_Params params;
|
|
params.DeltaRotation = DeltaRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddWorldOffset
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector DeltaLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddWorldOffset(const struct FVector& DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddWorldOffset");
|
|
|
|
USceneComponent_K2_AddWorldOffset_Params params;
|
|
params.DeltaLocation = DeltaLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddRelativeRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator DeltaRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddRelativeRotation(const struct FRotator& DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddRelativeRotation");
|
|
|
|
USceneComponent_K2_AddRelativeRotation_Params params;
|
|
params.DeltaRotation = DeltaRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddRelativeLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector DeltaLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddRelativeLocation(const struct FVector& DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddRelativeLocation");
|
|
|
|
USceneComponent_K2_AddRelativeLocation_Params params;
|
|
params.DeltaLocation = DeltaLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddLocalTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform DeltaTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddLocalTransform(const struct FTransform& DeltaTransform, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddLocalTransform");
|
|
|
|
USceneComponent_K2_AddLocalTransform_Params params;
|
|
params.DeltaTransform = DeltaTransform;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddLocalRotation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator DeltaRotation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddLocalRotation(const struct FRotator& DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddLocalRotation");
|
|
|
|
USceneComponent_K2_AddLocalRotation_Params params;
|
|
params.DeltaRotation = DeltaRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.K2_AddLocalOffset
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector DeltaLocation (Parm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepHitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::K2_AddLocalOffset(const struct FVector& DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult* SweepHitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.K2_AddLocalOffset");
|
|
|
|
USceneComponent_K2_AddLocalOffset_Params params;
|
|
params.DeltaLocation = DeltaLocation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SweepHitResult != nullptr)
|
|
*SweepHitResult = params.SweepHitResult;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.IsVisible
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::IsVisible()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.IsVisible");
|
|
|
|
USceneComponent_IsVisible_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.IsSimulatingPhysics
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::IsSimulatingPhysics(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.IsSimulatingPhysics");
|
|
|
|
USceneComponent_IsSimulatingPhysics_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.IsAnySimulatingPhysics
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::IsAnySimulatingPhysics()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.IsAnySimulatingPhysics");
|
|
|
|
USceneComponent_IsAnySimulatingPhysics_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetUpVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::GetUpVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetUpVector");
|
|
|
|
USceneComponent_GetUpVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetSocketTransform
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERelativeTransformSpace> TransformSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USceneComponent::GetSocketTransform(const struct FName& InSocketName, TEnumAsByte<ERelativeTransformSpace> TransformSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetSocketTransform");
|
|
|
|
USceneComponent_GetSocketTransform_Params params;
|
|
params.InSocketName = InSocketName;
|
|
params.TransformSpace = TransformSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetSocketRotation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USceneComponent::GetSocketRotation(const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetSocketRotation");
|
|
|
|
USceneComponent_GetSocketRotation_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetSocketQuaternion
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FQuat ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FQuat USceneComponent::GetSocketQuaternion(const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetSocketQuaternion");
|
|
|
|
USceneComponent_GetSocketQuaternion_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetSocketLocation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::GetSocketLocation(const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetSocketLocation");
|
|
|
|
USceneComponent_GetSocketLocation_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetRightVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::GetRightVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetRightVector");
|
|
|
|
USceneComponent_GetRightVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetRelativeTransform
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USceneComponent::GetRelativeTransform()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetRelativeTransform");
|
|
|
|
USceneComponent_GetRelativeTransform_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetPhysicsVolume
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APhysicsVolume* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APhysicsVolume* USceneComponent::GetPhysicsVolume()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetPhysicsVolume");
|
|
|
|
USceneComponent_GetPhysicsVolume_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetParentComponents
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class USceneComponent*> Parents (Parm, OutParm, ZeroConstructor)
|
|
|
|
void USceneComponent::GetParentComponents(TArray<class USceneComponent*>* Parents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetParentComponents");
|
|
|
|
USceneComponent_GetParentComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Parents != nullptr)
|
|
*Parents = params.Parents;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetNumChildrenComponents
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int USceneComponent::GetNumChildrenComponents()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetNumChildrenComponents");
|
|
|
|
USceneComponent_GetNumChildrenComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetForwardVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::GetForwardVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetForwardVector");
|
|
|
|
USceneComponent_GetForwardVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetComponentVelocity
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USceneComponent::GetComponentVelocity()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetComponentVelocity");
|
|
|
|
USceneComponent_GetComponentVelocity_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetComponentTransformViewTranslatedBP
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USceneComponent::GetComponentTransformViewTranslatedBP()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetComponentTransformViewTranslatedBP");
|
|
|
|
USceneComponent_GetComponentTransformViewTranslatedBP_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetComponentLocal
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform LocalTransform (Parm, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USceneComponent::GetComponentLocal(const struct FTransform& LocalTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetComponentLocal");
|
|
|
|
USceneComponent_GetComponentLocal_Params params;
|
|
params.LocalTransform = LocalTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetChildrenComponents
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool bIncludeAllDescendants (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class USceneComponent*> Children (Parm, OutParm, ZeroConstructor)
|
|
|
|
void USceneComponent::GetChildrenComponents(bool bIncludeAllDescendants, TArray<class USceneComponent*>* Children)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetChildrenComponents");
|
|
|
|
USceneComponent_GetChildrenComponents_Params params;
|
|
params.bIncludeAllDescendants = bIncludeAllDescendants;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Children != nullptr)
|
|
*Children = params.Children;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetChildComponent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ChildIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USceneComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class USceneComponent* USceneComponent::GetChildComponent(int ChildIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetChildComponent");
|
|
|
|
USceneComponent_GetChildComponent_Params params;
|
|
params.ChildIndex = ChildIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetAttachSocketName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName USceneComponent::GetAttachSocketName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetAttachSocketName");
|
|
|
|
USceneComponent_GetAttachSocketName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetAttachParent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class USceneComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class USceneComponent* USceneComponent::GetAttachParent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetAttachParent");
|
|
|
|
USceneComponent_GetAttachParent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.GetAllSocketNames
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FName> USceneComponent::GetAllSocketNames()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.GetAllSocketNames");
|
|
|
|
USceneComponent_GetAllSocketNames_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.DoesSocketExist
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USceneComponent::DoesSocketExist(const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.DoesSocketExist");
|
|
|
|
USceneComponent_DoesSocketExist_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneComponent.DetachFromParent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bMaintainWorldPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bCallModify (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneComponent::DetachFromParent(bool bMaintainWorldPosition, bool bCallModify)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneComponent.DetachFromParent");
|
|
|
|
USceneComponent_DetachFromParent_Params params;
|
|
params.bMaintainWorldPosition = bMaintainWorldPosition;
|
|
params.bCallModify = bCallModify;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.UnPossess
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AController::UnPossess()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.UnPossess");
|
|
|
|
AController_UnPossess_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.StopMovement
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AController::StopMovement()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.StopMovement");
|
|
|
|
AController_StopMovement_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.SetInitialLocationAndRotation
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator NewRotation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void AController::SetInitialLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.SetInitialLocationAndRotation");
|
|
|
|
AController_SetInitialLocationAndRotation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.NewRotation = NewRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.SetIgnoreMoveInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewMoveInput (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AController::SetIgnoreMoveInput(bool bNewMoveInput)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.SetIgnoreMoveInput");
|
|
|
|
AController_SetIgnoreMoveInput_Params params;
|
|
params.bNewMoveInput = bNewMoveInput;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.SetIgnoreLookInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewLookInput (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AController::SetIgnoreLookInput(bool bNewLookInput)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.SetIgnoreLookInput");
|
|
|
|
AController_SetIgnoreLookInput_Params params;
|
|
params.bNewLookInput = bNewLookInput;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.SetControlRotation
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator NewRotation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void AController::SetControlRotation(const struct FRotator& NewRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.SetControlRotation");
|
|
|
|
AController_SetControlRotation_Params params;
|
|
params.NewRotation = NewRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.ResetIgnoreMoveInput
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AController::ResetIgnoreMoveInput()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.ResetIgnoreMoveInput");
|
|
|
|
AController_ResetIgnoreMoveInput_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.ResetIgnoreLookInput
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AController::ResetIgnoreLookInput()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.ResetIgnoreLookInput");
|
|
|
|
AController_ResetIgnoreLookInput_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.ResetIgnoreInputFlags
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AController::ResetIgnoreInputFlags()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.ResetIgnoreInputFlags");
|
|
|
|
AController_ResetIgnoreInputFlags_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.ReceiveInstigatedAnyDamage
|
|
// (BlueprintAuthorityOnly, Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// float Damage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDamageType* DamageType (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamagedActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AController::ReceiveInstigatedAnyDamage(float Damage, class UDamageType* DamageType, class AActor* DamagedActor, class AActor* DamageCauser)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.ReceiveInstigatedAnyDamage");
|
|
|
|
AController_ReceiveInstigatedAnyDamage_Params params;
|
|
params.Damage = Damage;
|
|
params.DamageType = DamageType;
|
|
params.DamagedActor = DamagedActor;
|
|
params.DamageCauser = DamageCauser;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.Possess
|
|
// (BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APawn* InPawn (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AController::Possess(class APawn* InPawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.Possess");
|
|
|
|
AController_Possess_Params params;
|
|
params.InPawn = InPawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.OnRep_PlayerState
|
|
// (Native, Public)
|
|
|
|
void AController::OnRep_PlayerState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.OnRep_PlayerState");
|
|
|
|
AController_OnRep_PlayerState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.OnRep_Pawn
|
|
// (Native, Public)
|
|
|
|
void AController::OnRep_Pawn()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.OnRep_Pawn");
|
|
|
|
AController_OnRep_Pawn_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.LineOfSightTo
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* Other (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ViewPoint (Parm, IsPlainOldData)
|
|
// bool bAlternateChecks (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AController::LineOfSightTo(class AActor* Other, const struct FVector& ViewPoint, bool bAlternateChecks)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.LineOfSightTo");
|
|
|
|
AController_LineOfSightTo_Params params;
|
|
params.Other = Other;
|
|
params.ViewPoint = ViewPoint;
|
|
params.bAlternateChecks = bAlternateChecks;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.K2_GetPawn
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* AController::K2_GetPawn()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.K2_GetPawn");
|
|
|
|
AController_K2_GetPawn_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.IsPlayerController
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AController::IsPlayerController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.IsPlayerController");
|
|
|
|
AController_IsPlayerController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.IsMoveInputIgnored
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AController::IsMoveInputIgnored()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.IsMoveInputIgnored");
|
|
|
|
AController_IsMoveInputIgnored_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.IsLookInputIgnored
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AController::IsLookInputIgnored()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.IsLookInputIgnored");
|
|
|
|
AController_IsLookInputIgnored_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.IsLocalPlayerController
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AController::IsLocalPlayerController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.IsLocalPlayerController");
|
|
|
|
AController_IsLocalPlayerController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.IsLocalController
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AController::IsLocalController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.IsLocalController");
|
|
|
|
AController_IsLocalController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.GetViewTarget
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AController::GetViewTarget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.GetViewTarget");
|
|
|
|
AController_GetViewTarget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.GetDesiredRotation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator AController::GetDesiredRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.GetDesiredRotation");
|
|
|
|
AController_GetDesiredRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.GetControlRotation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator AController::GetControlRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.GetControlRotation");
|
|
|
|
AController_GetControlRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.ClientSetRotation
|
|
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// bool bResetCamera (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AController::ClientSetRotation(const struct FRotator& NewRotation, bool bResetCamera)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.ClientSetRotation");
|
|
|
|
AController_ClientSetRotation_Params params;
|
|
params.NewRotation = NewRotation;
|
|
params.bResetCamera = bResetCamera;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.ClientSetLocation
|
|
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
|
|
void AController::ClientSetLocation(const struct FVector& NewLocation, const struct FRotator& NewRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.ClientSetLocation");
|
|
|
|
AController_ClientSetLocation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.NewRotation = NewRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Controller.CastToPlayerController
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* AController::CastToPlayerController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Controller.CastToPlayerController");
|
|
|
|
AController_CastToPlayerController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.StartPlay
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameModeBase::StartPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.StartPlay");
|
|
|
|
AGameModeBase_StartPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.SpawnDefaultPawnFor
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* StartSpot (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* AGameModeBase::SpawnDefaultPawnFor(class AController* NewPlayer, class AActor* StartSpot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.SpawnDefaultPawnFor");
|
|
|
|
AGameModeBase_SpawnDefaultPawnFor_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
params.StartSpot = StartSpot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.SpawnDefaultPawnAtTransform
|
|
// (Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform SpawnTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* AGameModeBase::SpawnDefaultPawnAtTransform(class AController* NewPlayer, const struct FTransform& SpawnTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.SpawnDefaultPawnAtTransform");
|
|
|
|
AGameModeBase_SpawnDefaultPawnAtTransform_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
params.SpawnTransform = SpawnTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.ShouldReset
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* ActorToReset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameModeBase::ShouldReset(class AActor* ActorToReset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.ShouldReset");
|
|
|
|
AGameModeBase_ShouldReset_Params params;
|
|
params.ActorToReset = ActorToReset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.ReturnToMainMenuHost
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameModeBase::ReturnToMainMenuHost()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.ReturnToMainMenuHost");
|
|
|
|
AGameModeBase_ReturnToMainMenuHost_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.RestartPlayerAtTransform
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform SpawnTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void AGameModeBase::RestartPlayerAtTransform(class AController* NewPlayer, const struct FTransform& SpawnTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.RestartPlayerAtTransform");
|
|
|
|
AGameModeBase_RestartPlayerAtTransform_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
params.SpawnTransform = SpawnTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.RestartPlayerAtPlayerStart
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* StartSpot (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::RestartPlayerAtPlayerStart(class AController* NewPlayer, class AActor* StartSpot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.RestartPlayerAtPlayerStart");
|
|
|
|
AGameModeBase_RestartPlayerAtPlayerStart_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
params.StartSpot = StartSpot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.RestartPlayer
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::RestartPlayer(class AController* NewPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.RestartPlayer");
|
|
|
|
AGameModeBase_RestartPlayer_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.ResetLevel
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameModeBase::ResetLevel()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.ResetLevel");
|
|
|
|
AGameModeBase_ResetLevel_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.PlayerCanRestart
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameModeBase::PlayerCanRestart(class APlayerController* Player)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.PlayerCanRestart");
|
|
|
|
AGameModeBase_PlayerCanRestart_Params params;
|
|
params.Player = Player;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.MustSpectate
|
|
// (Native, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class APlayerController* NewPlayerController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameModeBase::MustSpectate(class APlayerController* NewPlayerController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.MustSpectate");
|
|
|
|
AGameModeBase_MustSpectate_Params params;
|
|
params.NewPlayerController = NewPlayerController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.K2_PostLogin
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::K2_PostLogin(class APlayerController* NewPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.K2_PostLogin");
|
|
|
|
AGameModeBase_K2_PostLogin_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.K2_OnSwapPlayerControllers
|
|
// (Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* OldPC (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* NewPC (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::K2_OnSwapPlayerControllers(class APlayerController* OldPC, class APlayerController* NewPC)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.K2_OnSwapPlayerControllers");
|
|
|
|
AGameModeBase_K2_OnSwapPlayerControllers_Params params;
|
|
params.OldPC = OldPC;
|
|
params.NewPC = NewPC;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.K2_OnRestartPlayer
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::K2_OnRestartPlayer(class AController* NewPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.K2_OnRestartPlayer");
|
|
|
|
AGameModeBase_K2_OnRestartPlayer_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.K2_OnLogout
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* ExitingController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::K2_OnLogout(class AController* ExitingController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.K2_OnLogout");
|
|
|
|
AGameModeBase_K2_OnLogout_Params params;
|
|
params.ExitingController = ExitingController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.K2_OnChangeName
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* Other (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString NewName (Parm, ZeroConstructor)
|
|
// bool bNameChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::K2_OnChangeName(class AController* Other, const struct FString& NewName, bool bNameChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.K2_OnChangeName");
|
|
|
|
AGameModeBase_K2_OnChangeName_Params params;
|
|
params.Other = Other;
|
|
params.NewName = NewName;
|
|
params.bNameChange = bNameChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.K2_FindPlayerStart
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class AController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString IncomingName (Parm, ZeroConstructor)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AGameModeBase::K2_FindPlayerStart(class AController* Player, const struct FString& IncomingName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.K2_FindPlayerStart");
|
|
|
|
AGameModeBase_K2_FindPlayerStart_Params params;
|
|
params.Player = Player;
|
|
params.IncomingName = IncomingName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.InitStartSpot
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* StartSpot (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::InitStartSpot(class AActor* StartSpot, class AController* NewPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.InitStartSpot");
|
|
|
|
AGameModeBase_InitStartSpot_Params params;
|
|
params.StartSpot = StartSpot;
|
|
params.NewPlayer = NewPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.InitializeHUDForPlayer
|
|
// (Native, Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::InitializeHUDForPlayer(class APlayerController* NewPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.InitializeHUDForPlayer");
|
|
|
|
AGameModeBase_InitializeHUDForPlayer_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.HasMatchStarted
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameModeBase::HasMatchStarted()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.HasMatchStarted");
|
|
|
|
AGameModeBase_HasMatchStarted_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.HandleStartingNewPlayer
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* NewPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::HandleStartingNewPlayer(class APlayerController* NewPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.HandleStartingNewPlayer");
|
|
|
|
AGameModeBase_HandleStartingNewPlayer_Params params;
|
|
params.NewPlayer = NewPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.GetNumSpectators
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int AGameModeBase::GetNumSpectators()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.GetNumSpectators");
|
|
|
|
AGameModeBase_GetNumSpectators_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.GetNumPlayers
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int AGameModeBase::GetNumPlayers()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.GetNumPlayers");
|
|
|
|
AGameModeBase_GetNumPlayers_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.GetDefaultPawnClassForController
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* InController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UClass* AGameModeBase::GetDefaultPawnClassForController(class AController* InController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.GetDefaultPawnClassForController");
|
|
|
|
AGameModeBase_GetDefaultPawnClassForController_Params params;
|
|
params.InController = InController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.FindPlayerStart
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString IncomingName (Parm, ZeroConstructor)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AGameModeBase::FindPlayerStart(class AController* Player, const struct FString& IncomingName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.FindPlayerStart");
|
|
|
|
AGameModeBase_FindPlayerStart_Params params;
|
|
params.Player = Player;
|
|
params.IncomingName = IncomingName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.ChoosePlayerStart
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* AGameModeBase::ChoosePlayerStart(class AController* Player)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.ChoosePlayerStart");
|
|
|
|
AGameModeBase_ChoosePlayerStart_Params params;
|
|
params.Player = Player;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.ChangeName
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AController* Controller (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString NewName (Parm, ZeroConstructor)
|
|
// bool bNameChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameModeBase::ChangeName(class AController* Controller, const struct FString& NewName, bool bNameChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.ChangeName");
|
|
|
|
AGameModeBase_ChangeName_Params params;
|
|
params.Controller = Controller;
|
|
params.NewName = NewName;
|
|
params.bNameChange = bNameChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameModeBase.CanSpectate
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* Viewer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerState* ViewTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameModeBase::CanSpectate(class APlayerController* Viewer, class APlayerState* ViewTarget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameModeBase.CanSpectate");
|
|
|
|
AGameModeBase_CanSpectate_Params params;
|
|
params.Viewer = Viewer;
|
|
params.ViewTarget = ViewTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.StartMatch
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameMode::StartMatch()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.StartMatch");
|
|
|
|
AGameMode_StartMatch_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.SetBandwidthLimit
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// float AsyncIOBandwidthLimit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameMode::SetBandwidthLimit(float AsyncIOBandwidthLimit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.SetBandwidthLimit");
|
|
|
|
AGameMode_SetBandwidthLimit_Params params;
|
|
params.AsyncIOBandwidthLimit = AsyncIOBandwidthLimit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.Say
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Msg (Parm, ZeroConstructor)
|
|
|
|
void AGameMode::Say(const struct FString& Msg)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.Say");
|
|
|
|
AGameMode_Say_Params params;
|
|
params.Msg = Msg;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.RestartGame
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameMode::RestartGame()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.RestartGame");
|
|
|
|
AGameMode_RestartGame_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.ReadyToStartMatch
|
|
// (Native, Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameMode::ReadyToStartMatch()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.ReadyToStartMatch");
|
|
|
|
AGameMode_ReadyToStartMatch_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.ReadyToEndMatch
|
|
// (Native, Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameMode::ReadyToEndMatch()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.ReadyToEndMatch");
|
|
|
|
AGameMode_ReadyToEndMatch_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.K2_OnSetMatchState
|
|
// (Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FName NewState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AGameMode::K2_OnSetMatchState(const struct FName& NewState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.K2_OnSetMatchState");
|
|
|
|
AGameMode_K2_OnSetMatchState_Params params;
|
|
params.NewState = NewState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.IsMatchInProgress
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameMode::IsMatchInProgress()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.IsMatchInProgress");
|
|
|
|
AGameMode_IsMatchInProgress_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.HasMatchEnded
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameMode::HasMatchEnded()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.HasMatchEnded");
|
|
|
|
AGameMode_HasMatchEnded_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.GetMatchState
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName AGameMode::GetMatchState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.GetMatchState");
|
|
|
|
AGameMode_GetMatchState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.EndMatch
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameMode::EndMatch()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.EndMatch");
|
|
|
|
AGameMode_EndMatch_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameMode.AbortMatch
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AGameMode::AbortMatch()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameMode.AbortMatch");
|
|
|
|
AGameMode_AbortMatch_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.OnRep_SpectatorClass
|
|
// (Native, Protected)
|
|
|
|
void AGameStateBase::OnRep_SpectatorClass()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.OnRep_SpectatorClass");
|
|
|
|
AGameStateBase_OnRep_SpectatorClass_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.OnRep_ReplicatedWorldTimeSeconds
|
|
// (Native, Protected)
|
|
|
|
void AGameStateBase::OnRep_ReplicatedWorldTimeSeconds()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.OnRep_ReplicatedWorldTimeSeconds");
|
|
|
|
AGameStateBase_OnRep_ReplicatedWorldTimeSeconds_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.OnRep_ReplicatedHasBegunPlay
|
|
// (Native, Protected)
|
|
|
|
void AGameStateBase::OnRep_ReplicatedHasBegunPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.OnRep_ReplicatedHasBegunPlay");
|
|
|
|
AGameStateBase_OnRep_ReplicatedHasBegunPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.OnRep_GameModeClass
|
|
// (Native, Protected)
|
|
|
|
void AGameStateBase::OnRep_GameModeClass()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.OnRep_GameModeClass");
|
|
|
|
AGameStateBase_OnRep_GameModeClass_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.HasMatchStarted
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameStateBase::HasMatchStarted()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.HasMatchStarted");
|
|
|
|
AGameStateBase_HasMatchStarted_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.HasBegunPlay
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AGameStateBase::HasBegunPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.HasBegunPlay");
|
|
|
|
AGameStateBase_HasBegunPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.GetServerWorldTimeSeconds
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AGameStateBase::GetServerWorldTimeSeconds()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.GetServerWorldTimeSeconds");
|
|
|
|
AGameStateBase_GetServerWorldTimeSeconds_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.GetPlayerStartTime
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AController* Controller (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AGameStateBase::GetPlayerStartTime(class AController* Controller)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.GetPlayerStartTime");
|
|
|
|
AGameStateBase_GetPlayerStartTime_Params params;
|
|
params.Controller = Controller;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameStateBase.GetPlayerRespawnDelay
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AController* Controller (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float AGameStateBase::GetPlayerRespawnDelay(class AController* Controller)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameStateBase.GetPlayerRespawnDelay");
|
|
|
|
AGameStateBase_GetPlayerRespawnDelay_Params params;
|
|
params.Controller = Controller;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameState.OnRep_MatchState
|
|
// (Native, Public)
|
|
|
|
void AGameState::OnRep_MatchState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameState.OnRep_MatchState");
|
|
|
|
AGameState_OnRep_MatchState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameState.OnRep_ElapsedTime
|
|
// (Native, Public)
|
|
|
|
void AGameState::OnRep_ElapsedTime()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameState.OnRep_ElapsedTime");
|
|
|
|
AGameState_OnRep_ElapsedTime_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerState.ReceiveOverrideWith
|
|
// (Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerState* OldPlayerState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerState::ReceiveOverrideWith(class APlayerState* OldPlayerState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerState.ReceiveOverrideWith");
|
|
|
|
APlayerState_ReceiveOverrideWith_Params params;
|
|
params.OldPlayerState = OldPlayerState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerState.ReceiveCopyProperties
|
|
// (Event, Protected, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerState* NewPlayerState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerState::ReceiveCopyProperties(class APlayerState* NewPlayerState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerState.ReceiveCopyProperties");
|
|
|
|
APlayerState_ReceiveCopyProperties_Params params;
|
|
params.NewPlayerState = NewPlayerState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerState.OnRep_UniqueId
|
|
// (Native, Public)
|
|
|
|
void APlayerState::OnRep_UniqueId()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerState.OnRep_UniqueId");
|
|
|
|
APlayerState_OnRep_UniqueId_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerState.OnRep_Score
|
|
// (Native, Public)
|
|
|
|
void APlayerState::OnRep_Score()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerState.OnRep_Score");
|
|
|
|
APlayerState_OnRep_Score_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerState.OnRep_PlayerName
|
|
// (Native, Public)
|
|
|
|
void APlayerState::OnRep_PlayerName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerState.OnRep_PlayerName");
|
|
|
|
APlayerState_OnRep_PlayerName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerState.OnRep_bIsInactive
|
|
// (Native, Public)
|
|
|
|
void APlayerState::OnRep_bIsInactive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerState.OnRep_bIsInactive");
|
|
|
|
APlayerState_OnRep_bIsInactive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.StopMovementImmediately
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UMovementComponent::StopMovementImmediately()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.StopMovementImmediately");
|
|
|
|
UMovementComponent_StopMovementImmediately_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SnapUpdatedComponentToPlane
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UMovementComponent::SnapUpdatedComponentToPlane()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SnapUpdatedComponentToPlane");
|
|
|
|
UMovementComponent_SnapUpdatedComponentToPlane_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SetUpdatedComponent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* NewUpdatedComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UMovementComponent::SetUpdatedComponent(class USceneComponent* NewUpdatedComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SetUpdatedComponent");
|
|
|
|
UMovementComponent_SetUpdatedComponent_Params params;
|
|
params.NewUpdatedComponent = NewUpdatedComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SetPlaneConstraintOrigin
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector PlaneOrigin (Parm, IsPlainOldData)
|
|
|
|
void UMovementComponent::SetPlaneConstraintOrigin(const struct FVector& PlaneOrigin)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SetPlaneConstraintOrigin");
|
|
|
|
UMovementComponent_SetPlaneConstraintOrigin_Params params;
|
|
params.PlaneOrigin = PlaneOrigin;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SetPlaneConstraintNormal
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector PlaneNormal (Parm, IsPlainOldData)
|
|
|
|
void UMovementComponent::SetPlaneConstraintNormal(const struct FVector& PlaneNormal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SetPlaneConstraintNormal");
|
|
|
|
UMovementComponent_SetPlaneConstraintNormal_Params params;
|
|
params.PlaneNormal = PlaneNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SetPlaneConstraintFromVectors
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Forward (Parm, IsPlainOldData)
|
|
// struct FVector Up (Parm, IsPlainOldData)
|
|
|
|
void UMovementComponent::SetPlaneConstraintFromVectors(const struct FVector& Forward, const struct FVector& Up)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SetPlaneConstraintFromVectors");
|
|
|
|
UMovementComponent_SetPlaneConstraintFromVectors_Params params;
|
|
params.Forward = Forward;
|
|
params.Up = Up;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SetPlaneConstraintEnabled
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMovementComponent::SetPlaneConstraintEnabled(bool bEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SetPlaneConstraintEnabled");
|
|
|
|
UMovementComponent_SetPlaneConstraintEnabled_Params params;
|
|
params.bEnabled = bEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.SetPlaneConstraintAxisSetting
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EPlaneConstraintAxisSetting NewAxisSetting (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMovementComponent::SetPlaneConstraintAxisSetting(EPlaneConstraintAxisSetting NewAxisSetting)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.SetPlaneConstraintAxisSetting");
|
|
|
|
UMovementComponent_SetPlaneConstraintAxisSetting_Params params;
|
|
params.NewAxisSetting = NewAxisSetting;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.PhysicsVolumeChanged
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// class APhysicsVolume* NewVolume (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMovementComponent::PhysicsVolumeChanged(class APhysicsVolume* NewVolume)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.PhysicsVolumeChanged");
|
|
|
|
UMovementComponent_PhysicsVolumeChanged_Params params;
|
|
params.NewVolume = NewVolume;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.K2_MoveUpdatedComponent
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Delta (Parm, IsPlainOldData)
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UMovementComponent::K2_MoveUpdatedComponent(const struct FVector& Delta, const struct FRotator& NewRotation, bool bSweep, bool bTeleport, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.K2_MoveUpdatedComponent");
|
|
|
|
UMovementComponent_K2_MoveUpdatedComponent_Params params;
|
|
params.Delta = Delta;
|
|
params.NewRotation = NewRotation;
|
|
params.bSweep = bSweep;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.K2_GetModifiedMaxSpeed
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UMovementComponent::K2_GetModifiedMaxSpeed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.K2_GetModifiedMaxSpeed");
|
|
|
|
UMovementComponent_K2_GetModifiedMaxSpeed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.K2_GetMaxSpeedModifier
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UMovementComponent::K2_GetMaxSpeedModifier()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.K2_GetMaxSpeedModifier");
|
|
|
|
UMovementComponent_K2_GetMaxSpeedModifier_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.IsExceedingMaxSpeed
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float MaxSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UMovementComponent::IsExceedingMaxSpeed(float MaxSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.IsExceedingMaxSpeed");
|
|
|
|
UMovementComponent_IsExceedingMaxSpeed_Params params;
|
|
params.MaxSpeed = MaxSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.GetPlaneConstraintOrigin
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData)
|
|
|
|
struct FVector UMovementComponent::GetPlaneConstraintOrigin()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.GetPlaneConstraintOrigin");
|
|
|
|
UMovementComponent_GetPlaneConstraintOrigin_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.GetPlaneConstraintNormal
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData)
|
|
|
|
struct FVector UMovementComponent::GetPlaneConstraintNormal()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.GetPlaneConstraintNormal");
|
|
|
|
UMovementComponent_GetPlaneConstraintNormal_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.GetPlaneConstraintAxisSetting
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// EPlaneConstraintAxisSetting ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
EPlaneConstraintAxisSetting UMovementComponent::GetPlaneConstraintAxisSetting()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.GetPlaneConstraintAxisSetting");
|
|
|
|
UMovementComponent_GetPlaneConstraintAxisSetting_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.GetPhysicsVolume
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APhysicsVolume* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APhysicsVolume* UMovementComponent::GetPhysicsVolume()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.GetPhysicsVolume");
|
|
|
|
UMovementComponent_GetPhysicsVolume_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.GetMaxSpeed
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UMovementComponent::GetMaxSpeed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.GetMaxSpeed");
|
|
|
|
UMovementComponent_GetMaxSpeed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.GetGravityZ
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UMovementComponent::GetGravityZ()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.GetGravityZ");
|
|
|
|
UMovementComponent_GetGravityZ_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.ConstrainNormalToPlane
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Normal (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UMovementComponent::ConstrainNormalToPlane(const struct FVector& Normal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.ConstrainNormalToPlane");
|
|
|
|
UMovementComponent_ConstrainNormalToPlane_Params params;
|
|
params.Normal = Normal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.ConstrainLocationToPlane
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UMovementComponent::ConstrainLocationToPlane(const struct FVector& Location)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.ConstrainLocationToPlane");
|
|
|
|
UMovementComponent_ConstrainLocationToPlane_Params params;
|
|
params.Location = Location;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MovementComponent.ConstrainDirectionToPlane
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Direction (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UMovementComponent::ConstrainDirectionToPlane(const struct FVector& Direction)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MovementComponent.ConstrainDirectionToPlane");
|
|
|
|
UMovementComponent_ConstrainDirectionToPlane_Params params;
|
|
params.Direction = Direction;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ProjectileMovementComponent.StopSimulating
|
|
// (Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FHitResult HitResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UProjectileMovementComponent::StopSimulating(const struct FHitResult& HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ProjectileMovementComponent.StopSimulating");
|
|
|
|
UProjectileMovementComponent_StopSimulating_Params params;
|
|
params.HitResult = HitResult;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ProjectileMovementComponent.SetVelocityInLocalSpace
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewVelocity (Parm, IsPlainOldData)
|
|
|
|
void UProjectileMovementComponent::SetVelocityInLocalSpace(const struct FVector& NewVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ProjectileMovementComponent.SetVelocityInLocalSpace");
|
|
|
|
UProjectileMovementComponent_SetVelocityInLocalSpace_Params params;
|
|
params.NewVelocity = NewVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.ProjectileMovementComponent.OnProjectileStopDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UProjectileMovementComponent::OnProjectileStopDelegate__DelegateSignature(const struct FHitResult& ImpactResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.ProjectileMovementComponent.OnProjectileStopDelegate__DelegateSignature");
|
|
|
|
UProjectileMovementComponent_OnProjectileStopDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.ProjectileMovementComponent.OnProjectileBounceDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms, HasDefaults)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector ImpactVelocity (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UProjectileMovementComponent::OnProjectileBounceDelegate__DelegateSignature(const struct FHitResult& ImpactResult, const struct FVector& ImpactVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.ProjectileMovementComponent.OnProjectileBounceDelegate__DelegateSignature");
|
|
|
|
UProjectileMovementComponent_OnProjectileBounceDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
params.ImpactVelocity = ImpactVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ProjectileMovementComponent.LimitVelocity
|
|
// (Final, Native, Protected, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector NewVelocity (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UProjectileMovementComponent::LimitVelocity(const struct FVector& NewVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ProjectileMovementComponent.LimitVelocity");
|
|
|
|
UProjectileMovementComponent_LimitVelocity_Params params;
|
|
params.NewVelocity = NewVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.WakeRigidBody
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::WakeRigidBody(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.WakeRigidBody");
|
|
|
|
UPrimitiveComponent_WakeRigidBody_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.WakeAllRigidBodies
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UPrimitiveComponent::WakeAllRigidBodies()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.WakeAllRigidBodies");
|
|
|
|
UPrimitiveComponent_WakeAllRigidBodies_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetWalkableSlopeOverride
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FWalkableSlopeOverride NewOverride (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetWalkableSlopeOverride(const struct FWalkableSlopeOverride& NewOverride)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetWalkableSlopeOverride");
|
|
|
|
UPrimitiveComponent_SetWalkableSlopeOverride_Params params;
|
|
params.NewOverride = NewOverride;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetTranslucentSortPriority
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewTranslucentSortPriority (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetTranslucentSortPriority(int NewTranslucentSortPriority)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetTranslucentSortPriority");
|
|
|
|
UPrimitiveComponent_SetTranslucentSortPriority_Params params;
|
|
params.NewTranslucentSortPriority = NewTranslucentSortPriority;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetSingleSampleShadowFromStationaryLights
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewSingleSampleShadowFromStationaryLights (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetSingleSampleShadowFromStationaryLights(bool bNewSingleSampleShadowFromStationaryLights)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetSingleSampleShadowFromStationaryLights");
|
|
|
|
UPrimitiveComponent_SetSingleSampleShadowFromStationaryLights_Params params;
|
|
params.bNewSingleSampleShadowFromStationaryLights = bNewSingleSampleShadowFromStationaryLights;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetSimulatePhysics
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bSimulate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetSimulatePhysics(bool bSimulate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetSimulatePhysics");
|
|
|
|
UPrimitiveComponent_SetSimulatePhysics_Params params;
|
|
params.bSimulate = bSimulate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetRenderInMono
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetRenderInMono(bool bValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetRenderInMono");
|
|
|
|
UPrimitiveComponent_SetRenderInMono_Params params;
|
|
params.bValue = bValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetRenderInMainPass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetRenderInMainPass(bool bValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetRenderInMainPass");
|
|
|
|
UPrimitiveComponent_SetRenderInMainPass_Params params;
|
|
params.bValue = bValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetRenderCustomDepth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetRenderCustomDepth(bool bValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetRenderCustomDepth");
|
|
|
|
UPrimitiveComponent_SetRenderCustomDepth_Params params;
|
|
params.bValue = bValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetReceivesDecals
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewReceivesDecals (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetReceivesDecals(bool bNewReceivesDecals)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetReceivesDecals");
|
|
|
|
UPrimitiveComponent_SetReceivesDecals_Params params;
|
|
params.bNewReceivesDecals = bNewReceivesDecals;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysMaterialOverride
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPhysicalMaterial* NewPhysMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysMaterialOverride(class UPhysicalMaterial* NewPhysMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysMaterialOverride");
|
|
|
|
UPrimitiveComponent_SetPhysMaterialOverride_Params params;
|
|
params.NewPhysMaterial = NewPhysMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsMaxAngularVelocityInRadians
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewMaxAngVel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsMaxAngularVelocityInRadians(float NewMaxAngVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsMaxAngularVelocityInRadians");
|
|
|
|
UPrimitiveComponent_SetPhysicsMaxAngularVelocityInRadians_Params params;
|
|
params.NewMaxAngVel = NewMaxAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsMaxAngularVelocityInDegrees
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewMaxAngVel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsMaxAngularVelocityInDegrees(float NewMaxAngVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsMaxAngularVelocityInDegrees");
|
|
|
|
UPrimitiveComponent_SetPhysicsMaxAngularVelocityInDegrees_Params params;
|
|
params.NewMaxAngVel = NewMaxAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsMaxAngularVelocity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewMaxAngVel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsMaxAngularVelocity(float NewMaxAngVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsMaxAngularVelocity");
|
|
|
|
UPrimitiveComponent_SetPhysicsMaxAngularVelocity_Params params;
|
|
params.NewMaxAngVel = NewMaxAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsLinearVelocity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewVel (Parm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsLinearVelocity(const struct FVector& NewVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsLinearVelocity");
|
|
|
|
UPrimitiveComponent_SetPhysicsLinearVelocity_Params params;
|
|
params.NewVel = NewVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsAngularVelocityInRadians
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewAngVel (Parm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsAngularVelocityInRadians(const struct FVector& NewAngVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsAngularVelocityInRadians");
|
|
|
|
UPrimitiveComponent_SetPhysicsAngularVelocityInRadians_Params params;
|
|
params.NewAngVel = NewAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsAngularVelocityInDegrees
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewAngVel (Parm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsAngularVelocityInDegrees(const struct FVector& NewAngVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsAngularVelocityInDegrees");
|
|
|
|
UPrimitiveComponent_SetPhysicsAngularVelocityInDegrees_Params params;
|
|
params.NewAngVel = NewAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetPhysicsAngularVelocity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewAngVel (Parm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetPhysicsAngularVelocity(const struct FVector& NewAngVel, bool bAddToCurrent, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetPhysicsAngularVelocity");
|
|
|
|
UPrimitiveComponent_SetPhysicsAngularVelocity_Params params;
|
|
params.NewAngVel = NewAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetOwnerNoSee
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewOwnerNoSee (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetOwnerNoSee(bool bNewOwnerNoSee)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetOwnerNoSee");
|
|
|
|
UPrimitiveComponent_SetOwnerNoSee_Params params;
|
|
params.bNewOwnerNoSee = bNewOwnerNoSee;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetOnlyOwnerSee
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewOnlyOwnerSee (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetOnlyOwnerSee(bool bNewOnlyOwnerSee)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetOnlyOwnerSee");
|
|
|
|
UPrimitiveComponent_SetOnlyOwnerSee_Params params;
|
|
params.bNewOnlyOwnerSee = bNewOnlyOwnerSee;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetNotifyRigidBodyCollision
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewNotifyRigidBodyCollision (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetNotifyRigidBodyCollision");
|
|
|
|
UPrimitiveComponent_SetNotifyRigidBodyCollision_Params params;
|
|
params.bNewNotifyRigidBodyCollision = bNewNotifyRigidBodyCollision;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetMaterialByName
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName MaterialSlotName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetMaterialByName(const struct FName& MaterialSlotName, class UMaterialInterface* Material)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetMaterialByName");
|
|
|
|
UPrimitiveComponent_SetMaterialByName_Params params;
|
|
params.MaterialSlotName = MaterialSlotName;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetMaterial
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ElementIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetMaterial(int ElementIndex, class UMaterialInterface* Material)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetMaterial");
|
|
|
|
UPrimitiveComponent_SetMaterial_Params params;
|
|
params.ElementIndex = ElementIndex;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetMassScale
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InMassScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetMassScale(const struct FName& BoneName, float InMassScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetMassScale");
|
|
|
|
UPrimitiveComponent_SetMassScale_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InMassScale = InMassScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetMassOverrideInKg
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MassInKg (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bOverrideMass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetMassOverrideInKg(const struct FName& BoneName, float MassInKg, bool bOverrideMass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetMassOverrideInKg");
|
|
|
|
UPrimitiveComponent_SetMassOverrideInKg_Params params;
|
|
params.BoneName = BoneName;
|
|
params.MassInKg = MassInKg;
|
|
params.bOverrideMass = bOverrideMass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetLockedAxis
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EDOFMode> LockedAxis (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetLockedAxis(TEnumAsByte<EDOFMode> LockedAxis)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetLockedAxis");
|
|
|
|
UPrimitiveComponent_SetLockedAxis_Params params;
|
|
params.LockedAxis = LockedAxis;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetLinearDamping
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InDamping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetLinearDamping(float InDamping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetLinearDamping");
|
|
|
|
UPrimitiveComponent_SetLinearDamping_Params params;
|
|
params.InDamping = InDamping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetEnableGravity
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bGravityEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetEnableGravity(bool bGravityEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetEnableGravity");
|
|
|
|
UPrimitiveComponent_SetEnableGravity_Params params;
|
|
params.bGravityEnabled = bGravityEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCustomDepthStencilWriteMask
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ERendererStencilMask WriteMaskBit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCustomDepthStencilWriteMask(ERendererStencilMask WriteMaskBit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCustomDepthStencilWriteMask");
|
|
|
|
UPrimitiveComponent_SetCustomDepthStencilWriteMask_Params params;
|
|
params.WriteMaskBit = WriteMaskBit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCustomDepthStencilValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCustomDepthStencilValue(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCustomDepthStencilValue");
|
|
|
|
UPrimitiveComponent_SetCustomDepthStencilValue_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCullDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewCullDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCullDistance(float NewCullDistance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCullDistance");
|
|
|
|
UPrimitiveComponent_SetCullDistance_Params params;
|
|
params.NewCullDistance = NewCullDistance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetConstraintMode
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EDOFMode> ConstraintMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetConstraintMode(TEnumAsByte<EDOFMode> ConstraintMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetConstraintMode");
|
|
|
|
UPrimitiveComponent_SetConstraintMode_Params params;
|
|
params.ConstraintMode = ConstraintMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCollisionResponseToChannel
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionChannel> Channel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECollisionResponse> NewResponse (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCollisionResponseToChannel(TEnumAsByte<ECollisionChannel> Channel, TEnumAsByte<ECollisionResponse> NewResponse)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCollisionResponseToChannel");
|
|
|
|
UPrimitiveComponent_SetCollisionResponseToChannel_Params params;
|
|
params.Channel = Channel;
|
|
params.NewResponse = NewResponse;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCollisionResponseToAllChannels
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionResponse> NewResponse (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCollisionResponseToAllChannels(TEnumAsByte<ECollisionResponse> NewResponse)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCollisionResponseToAllChannels");
|
|
|
|
UPrimitiveComponent_SetCollisionResponseToAllChannels_Params params;
|
|
params.NewResponse = NewResponse;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCollisionProfileName
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InCollisionProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCollisionProfileName(const struct FName& InCollisionProfileName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCollisionProfileName");
|
|
|
|
UPrimitiveComponent_SetCollisionProfileName_Params params;
|
|
params.InCollisionProfileName = InCollisionProfileName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCollisionObjectType
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionChannel> Channel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCollisionObjectType(TEnumAsByte<ECollisionChannel> Channel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCollisionObjectType");
|
|
|
|
UPrimitiveComponent_SetCollisionObjectType_Params params;
|
|
params.Channel = Channel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCollisionEnabled
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionEnabled> NewType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCollisionEnabled(TEnumAsByte<ECollisionEnabled> NewType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCollisionEnabled");
|
|
|
|
UPrimitiveComponent_SetCollisionEnabled_Params params;
|
|
params.NewType = NewType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCenterOfMass
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector CenterOfMassOffset (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCenterOfMass(const struct FVector& CenterOfMassOffset, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCenterOfMass");
|
|
|
|
UPrimitiveComponent_SetCenterOfMass_Params params;
|
|
params.CenterOfMassOffset = CenterOfMassOffset;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetCastShadow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewCastShadow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetCastShadow(bool NewCastShadow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetCastShadow");
|
|
|
|
UPrimitiveComponent_SetCastShadow_Params params;
|
|
params.NewCastShadow = NewCastShadow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetBoundsScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewBoundsScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetBoundsScale(float NewBoundsScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetBoundsScale");
|
|
|
|
UPrimitiveComponent_SetBoundsScale_Params params;
|
|
params.NewBoundsScale = NewBoundsScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetAngularDamping
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InDamping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetAngularDamping(float InDamping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetAngularDamping");
|
|
|
|
UPrimitiveComponent_SetAngularDamping_Params params;
|
|
params.InDamping = InDamping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetAllPhysicsLinearVelocity
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewVel (Parm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetAllPhysicsLinearVelocity(const struct FVector& NewVel, bool bAddToCurrent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetAllPhysicsLinearVelocity");
|
|
|
|
UPrimitiveComponent_SetAllPhysicsLinearVelocity_Params params;
|
|
params.NewVel = NewVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetAllPhysicsAngularVelocityInRadians
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewAngVel (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetAllPhysicsAngularVelocityInRadians(const struct FVector& NewAngVel, bool bAddToCurrent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetAllPhysicsAngularVelocityInRadians");
|
|
|
|
UPrimitiveComponent_SetAllPhysicsAngularVelocityInRadians_Params params;
|
|
params.NewAngVel = NewAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetAllPhysicsAngularVelocityInDegrees
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewAngVel (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetAllPhysicsAngularVelocityInDegrees(const struct FVector& NewAngVel, bool bAddToCurrent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetAllPhysicsAngularVelocityInDegrees");
|
|
|
|
UPrimitiveComponent_SetAllPhysicsAngularVelocityInDegrees_Params params;
|
|
params.NewAngVel = NewAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetAllPhysicsAngularVelocity
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewAngVel (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bAddToCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetAllPhysicsAngularVelocity(const struct FVector& NewAngVel, bool bAddToCurrent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetAllPhysicsAngularVelocity");
|
|
|
|
UPrimitiveComponent_SetAllPhysicsAngularVelocity_Params params;
|
|
params.NewAngVel = NewAngVel;
|
|
params.bAddToCurrent = bAddToCurrent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.SetAllMassScale
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMassScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::SetAllMassScale(float InMassScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.SetAllMassScale");
|
|
|
|
UPrimitiveComponent_SetAllMassScale_Params params;
|
|
params.InMassScale = InMassScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.ScaleByMomentOfInertia
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector InputVector (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::ScaleByMomentOfInertia(const struct FVector& InputVector, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.ScaleByMomentOfInertia");
|
|
|
|
UPrimitiveComponent_ScaleByMomentOfInertia_Params params;
|
|
params.InputVector = InputVector;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.PutRigidBodyToSleep
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::PutRigidBodyToSleep(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.PutRigidBodyToSleep");
|
|
|
|
UPrimitiveComponent_PutRigidBodyToSleep_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.K2_LineTraceComponent
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector TraceStart (Parm, IsPlainOldData)
|
|
// struct FVector TraceEnd (Parm, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShowTrace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector HitLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector HitNormal (Parm, OutParm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::K2_LineTraceComponent(const struct FVector& TraceStart, const struct FVector& TraceEnd, bool bTraceComplex, bool bShowTrace, struct FVector* HitLocation, struct FVector* HitNormal, struct FName* BoneName, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.K2_LineTraceComponent");
|
|
|
|
UPrimitiveComponent_K2_LineTraceComponent_Params params;
|
|
params.TraceStart = TraceStart;
|
|
params.TraceEnd = TraceEnd;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.bShowTrace = bShowTrace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitLocation != nullptr)
|
|
*HitLocation = params.HitLocation;
|
|
if (HitNormal != nullptr)
|
|
*HitNormal = params.HitNormal;
|
|
if (BoneName != nullptr)
|
|
*BoneName = params.BoneName;
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.K2_IsQueryCollisionEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::K2_IsQueryCollisionEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.K2_IsQueryCollisionEnabled");
|
|
|
|
UPrimitiveComponent_K2_IsQueryCollisionEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.K2_IsPhysicsCollisionEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::K2_IsPhysicsCollisionEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.K2_IsPhysicsCollisionEnabled");
|
|
|
|
UPrimitiveComponent_K2_IsPhysicsCollisionEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.K2_IsCollisionEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::K2_IsCollisionEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.K2_IsCollisionEnabled");
|
|
|
|
UPrimitiveComponent_K2_IsCollisionEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.IsOverlappingComponent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* OtherComp (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::IsOverlappingComponent(class UPrimitiveComponent* OtherComp)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.IsOverlappingComponent");
|
|
|
|
UPrimitiveComponent_IsOverlappingComponent_Params params;
|
|
params.OtherComp = OtherComp;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.IsOverlappingActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* Other (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::IsOverlappingActor(class AActor* Other)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.IsOverlappingActor");
|
|
|
|
UPrimitiveComponent_IsOverlappingActor_Params params;
|
|
params.Other = Other;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.IsGravityEnabled
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::IsGravityEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.IsGravityEnabled");
|
|
|
|
UPrimitiveComponent_IsGravityEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.IsAnyRigidBodyAwake
|
|
// (Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::IsAnyRigidBodyAwake()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.IsAnyRigidBodyAwake");
|
|
|
|
UPrimitiveComponent_IsAnyRigidBodyAwake_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.IgnoreComponentWhenMoving
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// bool bShouldIgnore (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::IgnoreComponentWhenMoving(class UPrimitiveComponent* Component, bool bShouldIgnore)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.IgnoreComponentWhenMoving");
|
|
|
|
UPrimitiveComponent_IgnoreComponentWhenMoving_Params params;
|
|
params.Component = Component;
|
|
params.bShouldIgnore = bShouldIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.IgnoreActorWhenMoving
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShouldIgnore (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::IgnoreActorWhenMoving(class AActor* Actor, bool bShouldIgnore)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.IgnoreActorWhenMoving");
|
|
|
|
UPrimitiveComponent_IgnoreActorWhenMoving_Params params;
|
|
params.Actor = Actor;
|
|
params.bShouldIgnore = bShouldIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetWalkableSlopeOverride
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FWalkableSlopeOverride ReturnValue (ConstParm, Parm, OutParm, ReturnParm, ReferenceParm, IsPlainOldData)
|
|
|
|
struct FWalkableSlopeOverride UPrimitiveComponent::GetWalkableSlopeOverride()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetWalkableSlopeOverride");
|
|
|
|
UPrimitiveComponent_GetWalkableSlopeOverride_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetPhysicsLinearVelocityAtPoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetPhysicsLinearVelocityAtPoint(const struct FVector& Point, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetPhysicsLinearVelocityAtPoint");
|
|
|
|
UPrimitiveComponent_GetPhysicsLinearVelocityAtPoint_Params params;
|
|
params.Point = Point;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetPhysicsLinearVelocity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetPhysicsLinearVelocity(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetPhysicsLinearVelocity");
|
|
|
|
UPrimitiveComponent_GetPhysicsLinearVelocity_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetPhysicsAngularVelocityInRadians
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetPhysicsAngularVelocityInRadians(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetPhysicsAngularVelocityInRadians");
|
|
|
|
UPrimitiveComponent_GetPhysicsAngularVelocityInRadians_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetPhysicsAngularVelocityInDegrees
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetPhysicsAngularVelocityInDegrees(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetPhysicsAngularVelocityInDegrees");
|
|
|
|
UPrimitiveComponent_GetPhysicsAngularVelocityInDegrees_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetPhysicsAngularVelocity
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetPhysicsAngularVelocity(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetPhysicsAngularVelocity");
|
|
|
|
UPrimitiveComponent_GetPhysicsAngularVelocity_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetOverlappingComponents
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class UPrimitiveComponent*> InOverlappingComponents (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UPrimitiveComponent::GetOverlappingComponents(TArray<class UPrimitiveComponent*>* InOverlappingComponents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetOverlappingComponents");
|
|
|
|
UPrimitiveComponent_GetOverlappingComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (InOverlappingComponents != nullptr)
|
|
*InOverlappingComponents = params.InOverlappingComponents;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetOverlappingActors
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class AActor*> OverlappingActors (Parm, OutParm, ZeroConstructor)
|
|
// class UClass* ClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::GetOverlappingActors(class UClass* ClassFilter, TArray<class AActor*>* OverlappingActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetOverlappingActors");
|
|
|
|
UPrimitiveComponent_GetOverlappingActors_Params params;
|
|
params.ClassFilter = ClassFilter;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OverlappingActors != nullptr)
|
|
*OverlappingActors = params.OverlappingActors;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetNumMaterials
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UPrimitiveComponent::GetNumMaterials()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetNumMaterials");
|
|
|
|
UPrimitiveComponent_GetNumMaterials_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetMaterialFromCollisionFaceIndex
|
|
// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int FaceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SectionIndex (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* UPrimitiveComponent::GetMaterialFromCollisionFaceIndex(int FaceIndex, int* SectionIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetMaterialFromCollisionFaceIndex");
|
|
|
|
UPrimitiveComponent_GetMaterialFromCollisionFaceIndex_Params params;
|
|
params.FaceIndex = FaceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SectionIndex != nullptr)
|
|
*SectionIndex = params.SectionIndex;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetMaterial
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ElementIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* UPrimitiveComponent::GetMaterial(int ElementIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetMaterial");
|
|
|
|
UPrimitiveComponent_GetMaterial_Params params;
|
|
params.ElementIndex = ElementIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetMassScale
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPrimitiveComponent::GetMassScale(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetMassScale");
|
|
|
|
UPrimitiveComponent_GetMassScale_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetMass
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPrimitiveComponent::GetMass()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetMass");
|
|
|
|
UPrimitiveComponent_GetMass_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetLinearDamping
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPrimitiveComponent::GetLinearDamping()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetLinearDamping");
|
|
|
|
UPrimitiveComponent_GetLinearDamping_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetInertiaTensor
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetInertiaTensor(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetInertiaTensor");
|
|
|
|
UPrimitiveComponent_GetInertiaTensor_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetCollisionResponseToChannel
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionChannel> Channel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECollisionResponse> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ECollisionResponse> UPrimitiveComponent::GetCollisionResponseToChannel(TEnumAsByte<ECollisionChannel> Channel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetCollisionResponseToChannel");
|
|
|
|
UPrimitiveComponent_GetCollisionResponseToChannel_Params params;
|
|
params.Channel = Channel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetCollisionProfileName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UPrimitiveComponent::GetCollisionProfileName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetCollisionProfileName");
|
|
|
|
UPrimitiveComponent_GetCollisionProfileName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetCollisionObjectType
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionChannel> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ECollisionChannel> UPrimitiveComponent::GetCollisionObjectType()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetCollisionObjectType");
|
|
|
|
UPrimitiveComponent_GetCollisionObjectType_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetCollisionEnabled
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionEnabled> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ECollisionEnabled> UPrimitiveComponent::GetCollisionEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetCollisionEnabled");
|
|
|
|
UPrimitiveComponent_GetCollisionEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetClosestPointOnCollision
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Point (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector OutPointOnBody (Parm, OutParm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPrimitiveComponent::GetClosestPointOnCollision(const struct FVector& Point, const struct FName& BoneName, struct FVector* OutPointOnBody)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetClosestPointOnCollision");
|
|
|
|
UPrimitiveComponent_GetClosestPointOnCollision_Params params;
|
|
params.Point = Point;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutPointOnBody != nullptr)
|
|
*OutPointOnBody = params.OutPointOnBody;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetCenterOfMass
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPrimitiveComponent::GetCenterOfMass(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetCenterOfMass");
|
|
|
|
UPrimitiveComponent_GetCenterOfMass_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.GetAngularDamping
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPrimitiveComponent::GetAngularDamping()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.GetAngularDamping");
|
|
|
|
UPrimitiveComponent_GetAngularDamping_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.CreateDynamicMaterialInstance
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ElementIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* SourceMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UPrimitiveComponent::CreateDynamicMaterialInstance(int ElementIndex, class UMaterialInterface* SourceMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.CreateDynamicMaterialInstance");
|
|
|
|
UPrimitiveComponent_CreateDynamicMaterialInstance_Params params;
|
|
params.ElementIndex = ElementIndex;
|
|
params.SourceMaterial = SourceMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.CreateAndSetMaterialInstanceDynamicFromMaterial
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ElementIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Parent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UPrimitiveComponent::CreateAndSetMaterialInstanceDynamicFromMaterial(int ElementIndex, class UMaterialInterface* Parent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.CreateAndSetMaterialInstanceDynamicFromMaterial");
|
|
|
|
UPrimitiveComponent_CreateAndSetMaterialInstanceDynamicFromMaterial_Params params;
|
|
params.ElementIndex = ElementIndex;
|
|
params.Parent = Parent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.CreateAndSetMaterialInstanceDynamic
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ElementIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UPrimitiveComponent::CreateAndSetMaterialInstanceDynamic(int ElementIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.CreateAndSetMaterialInstanceDynamic");
|
|
|
|
UPrimitiveComponent_CreateAndSetMaterialInstanceDynamic_Params params;
|
|
params.ElementIndex = ElementIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.CopyArrayOfMoveIgnoreComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class UPrimitiveComponent*> ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<class UPrimitiveComponent*> UPrimitiveComponent::CopyArrayOfMoveIgnoreComponents()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.CopyArrayOfMoveIgnoreComponents");
|
|
|
|
UPrimitiveComponent_CopyArrayOfMoveIgnoreComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.CopyArrayOfMoveIgnoreActors
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class AActor*> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<class AActor*> UPrimitiveComponent::CopyArrayOfMoveIgnoreActors()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.CopyArrayOfMoveIgnoreActors");
|
|
|
|
UPrimitiveComponent_CopyArrayOfMoveIgnoreActors_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.ClearMoveIgnoreComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UPrimitiveComponent::ClearMoveIgnoreComponents()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.ClearMoveIgnoreComponents");
|
|
|
|
UPrimitiveComponent_ClearMoveIgnoreComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.ClearMoveIgnoreActors
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UPrimitiveComponent::ClearMoveIgnoreActors()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.ClearMoveIgnoreActors");
|
|
|
|
UPrimitiveComponent_ClearMoveIgnoreActors_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.CanCharacterStepUp
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* Pawn (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPrimitiveComponent::CanCharacterStepUp(class APawn* Pawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.CanCharacterStepUp");
|
|
|
|
UPrimitiveComponent_CanCharacterStepUp_Params params;
|
|
params.Pawn = Pawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddTorqueInRadians
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Torque (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAccelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddTorqueInRadians(const struct FVector& Torque, const struct FName& BoneName, bool bAccelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddTorqueInRadians");
|
|
|
|
UPrimitiveComponent_AddTorqueInRadians_Params params;
|
|
params.Torque = Torque;
|
|
params.BoneName = BoneName;
|
|
params.bAccelChange = bAccelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddTorqueInDegrees
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Torque (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAccelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddTorqueInDegrees(const struct FVector& Torque, const struct FName& BoneName, bool bAccelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddTorqueInDegrees");
|
|
|
|
UPrimitiveComponent_AddTorqueInDegrees_Params params;
|
|
params.Torque = Torque;
|
|
params.BoneName = BoneName;
|
|
params.bAccelChange = bAccelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddTorque
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Torque (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAccelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddTorque(const struct FVector& Torque, const struct FName& BoneName, bool bAccelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddTorque");
|
|
|
|
UPrimitiveComponent_AddTorque_Params params;
|
|
params.Torque = Torque;
|
|
params.BoneName = BoneName;
|
|
params.bAccelChange = bAccelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddRadialImpulse
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Origin (Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Strength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERadialImpulseFalloff> Falloff (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bVelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddRadialImpulse(const struct FVector& Origin, float Radius, float Strength, TEnumAsByte<ERadialImpulseFalloff> Falloff, bool bVelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddRadialImpulse");
|
|
|
|
UPrimitiveComponent_AddRadialImpulse_Params params;
|
|
params.Origin = Origin;
|
|
params.Radius = Radius;
|
|
params.Strength = Strength;
|
|
params.Falloff = Falloff;
|
|
params.bVelChange = bVelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddRadialForce
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Origin (Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Strength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERadialImpulseFalloff> Falloff (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAccelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddRadialForce(const struct FVector& Origin, float Radius, float Strength, TEnumAsByte<ERadialImpulseFalloff> Falloff, bool bAccelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddRadialForce");
|
|
|
|
UPrimitiveComponent_AddRadialForce_Params params;
|
|
params.Origin = Origin;
|
|
params.Radius = Radius;
|
|
params.Strength = Strength;
|
|
params.Falloff = Falloff;
|
|
params.bAccelChange = bAccelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddImpulseAtLocation
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddImpulseAtLocation(const struct FVector& Impulse, const struct FVector& Location, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddImpulseAtLocation");
|
|
|
|
UPrimitiveComponent_AddImpulseAtLocation_Params params;
|
|
params.Impulse = Impulse;
|
|
params.Location = Location;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddImpulse
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bVelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddImpulse(const struct FVector& Impulse, const struct FName& BoneName, bool bVelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddImpulse");
|
|
|
|
UPrimitiveComponent_AddImpulse_Params params;
|
|
params.Impulse = Impulse;
|
|
params.BoneName = BoneName;
|
|
params.bVelChange = bVelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddForceAtLocationLocal
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector force (Parm, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddForceAtLocationLocal(const struct FVector& force, const struct FVector& Location, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddForceAtLocationLocal");
|
|
|
|
UPrimitiveComponent_AddForceAtLocationLocal_Params params;
|
|
params.force = force;
|
|
params.Location = Location;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddForceAtLocation
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector force (Parm, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddForceAtLocation(const struct FVector& force, const struct FVector& Location, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddForceAtLocation");
|
|
|
|
UPrimitiveComponent_AddForceAtLocation_Params params;
|
|
params.force = force;
|
|
params.Location = Location;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddForce
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector force (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAccelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddForce(const struct FVector& force, const struct FName& BoneName, bool bAccelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddForce");
|
|
|
|
UPrimitiveComponent_AddForce_Params params;
|
|
params.force = force;
|
|
params.BoneName = BoneName;
|
|
params.bAccelChange = bAccelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddAngularImpulseInRadians
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bVelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddAngularImpulseInRadians(const struct FVector& Impulse, const struct FName& BoneName, bool bVelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddAngularImpulseInRadians");
|
|
|
|
UPrimitiveComponent_AddAngularImpulseInRadians_Params params;
|
|
params.Impulse = Impulse;
|
|
params.BoneName = BoneName;
|
|
params.bVelChange = bVelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddAngularImpulseInDegrees
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bVelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddAngularImpulseInDegrees(const struct FVector& Impulse, const struct FName& BoneName, bool bVelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddAngularImpulseInDegrees");
|
|
|
|
UPrimitiveComponent_AddAngularImpulseInDegrees_Params params;
|
|
params.Impulse = Impulse;
|
|
params.BoneName = BoneName;
|
|
params.bVelChange = bVelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PrimitiveComponent.AddAngularImpulse
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bVelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPrimitiveComponent::AddAngularImpulse(const struct FVector& Impulse, const struct FName& BoneName, bool bVelChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PrimitiveComponent.AddAngularImpulse");
|
|
|
|
UPrimitiveComponent_AddAngularImpulse_Params params;
|
|
params.Impulse = Impulse;
|
|
params.BoneName = BoneName;
|
|
params.bVelChange = bVelChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetVectorParameter
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Param (Parm, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetVectorParameter(const struct FName& ParameterName, const struct FVector& Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetVectorParameter");
|
|
|
|
UParticleSystemComponent_SetVectorParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetTrailSourceData
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InFirstSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName InSecondSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETrailWidthMode> InWidthMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetTrailSourceData(const struct FName& InFirstSocketName, const struct FName& InSecondSocketName, TEnumAsByte<ETrailWidthMode> InWidthMode, float InWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetTrailSourceData");
|
|
|
|
UParticleSystemComponent_SetTrailSourceData_Params params;
|
|
params.InFirstSocketName = InFirstSocketName;
|
|
params.InSecondSocketName = InSecondSocketName;
|
|
params.InWidthMode = InWidthMode;
|
|
params.InWidth = InWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetTemplate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UParticleSystem* NewTemplate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetTemplate(class UParticleSystem* NewTemplate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetTemplate");
|
|
|
|
UParticleSystemComponent_SetTemplate_Params params;
|
|
params.NewTemplate = NewTemplate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetMaterialParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Param (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetMaterialParameter(const struct FName& ParameterName, class UMaterialInterface* Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetMaterialParameter");
|
|
|
|
UParticleSystemComponent_SetMaterialParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetFloatParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Param (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetFloatParameter(const struct FName& ParameterName, float Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetFloatParameter");
|
|
|
|
UParticleSystemComponent_SetFloatParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetEmitterEnable
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName EmitterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bNewEnableState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetEmitterEnable(const struct FName& EmitterName, bool bNewEnableState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetEmitterEnable");
|
|
|
|
UParticleSystemComponent_SetEmitterEnable_Params params;
|
|
params.EmitterName = EmitterName;
|
|
params.bNewEnableState = bNewEnableState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetColorParameter
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Param (Parm, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetColorParameter(const struct FName& ParameterName, const struct FLinearColor& Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetColorParameter");
|
|
|
|
UParticleSystemComponent_SetColorParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamTargetTangent
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewTangentPoint (Parm, IsPlainOldData)
|
|
// int TargetIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamTargetTangent(int EmitterIndex, const struct FVector& NewTangentPoint, int TargetIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamTargetTangent");
|
|
|
|
UParticleSystemComponent_SetBeamTargetTangent_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewTangentPoint = NewTangentPoint;
|
|
params.TargetIndex = TargetIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamTargetStrength
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NewTargetStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TargetIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamTargetStrength(int EmitterIndex, float NewTargetStrength, int TargetIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamTargetStrength");
|
|
|
|
UParticleSystemComponent_SetBeamTargetStrength_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewTargetStrength = NewTargetStrength;
|
|
params.TargetIndex = TargetIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamTargetPoint
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewTargetPoint (Parm, IsPlainOldData)
|
|
// int TargetIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamTargetPoint(int EmitterIndex, const struct FVector& NewTargetPoint, int TargetIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamTargetPoint");
|
|
|
|
UParticleSystemComponent_SetBeamTargetPoint_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewTargetPoint = NewTargetPoint;
|
|
params.TargetIndex = TargetIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamSourceTangent
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewTangentPoint (Parm, IsPlainOldData)
|
|
// int SourceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamSourceTangent(int EmitterIndex, const struct FVector& NewTangentPoint, int SourceIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamSourceTangent");
|
|
|
|
UParticleSystemComponent_SetBeamSourceTangent_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewTangentPoint = NewTangentPoint;
|
|
params.SourceIndex = SourceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamSourceStrength
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NewSourceStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SourceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamSourceStrength(int EmitterIndex, float NewSourceStrength, int SourceIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamSourceStrength");
|
|
|
|
UParticleSystemComponent_SetBeamSourceStrength_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewSourceStrength = NewSourceStrength;
|
|
params.SourceIndex = SourceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamSourcePoint
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewSourcePoint (Parm, IsPlainOldData)
|
|
// int SourceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamSourcePoint(int EmitterIndex, const struct FVector& NewSourcePoint, int SourceIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamSourcePoint");
|
|
|
|
UParticleSystemComponent_SetBeamSourcePoint_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewSourcePoint = NewSourcePoint;
|
|
params.SourceIndex = SourceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetBeamEndPoint
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewEndPoint (Parm, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetBeamEndPoint(int EmitterIndex, const struct FVector& NewEndPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetBeamEndPoint");
|
|
|
|
UParticleSystemComponent_SetBeamEndPoint_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.NewEndPoint = NewEndPoint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetAutoAttachParams
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* Parent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName SocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetAutoAttachParams(class USceneComponent* Parent, const struct FName& SocketName, TEnumAsByte<EAttachLocation> LocationType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetAutoAttachParams");
|
|
|
|
UParticleSystemComponent_SetAutoAttachParams_Params params;
|
|
params.Parent = Parent;
|
|
params.SocketName = SocketName;
|
|
params.LocationType = LocationType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetAutoAttachmentParameters
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* Parent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName SocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule LocationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule RotationRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EAttachmentRule ScaleRule (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetAutoAttachmentParameters(class USceneComponent* Parent, const struct FName& SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetAutoAttachmentParameters");
|
|
|
|
UParticleSystemComponent_SetAutoAttachmentParameters_Params params;
|
|
params.Parent = Parent;
|
|
params.SocketName = SocketName;
|
|
params.LocationRule = LocationRule;
|
|
params.RotationRule = RotationRule;
|
|
params.ScaleRule = ScaleRule;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.SetActorParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Param (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::SetActorParameter(const struct FName& ParameterName, class AActor* Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.SetActorParameter");
|
|
|
|
UParticleSystemComponent_SetActorParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetNumActiveParticles
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UParticleSystemComponent::GetNumActiveParticles()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetNumActiveParticles");
|
|
|
|
UParticleSystemComponent_GetNumActiveParticles_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetNamedMaterial
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* UParticleSystemComponent::GetNamedMaterial(const struct FName& InName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetNamedMaterial");
|
|
|
|
UParticleSystemComponent_GetNamedMaterial_Params params;
|
|
params.InName = InName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamTargetTangent
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TargetIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector OutTangentPoint (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamTargetTangent(int EmitterIndex, int TargetIndex, struct FVector* OutTangentPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamTargetTangent");
|
|
|
|
UParticleSystemComponent_GetBeamTargetTangent_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.TargetIndex = TargetIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutTangentPoint != nullptr)
|
|
*OutTangentPoint = params.OutTangentPoint;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamTargetStrength
|
|
// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TargetIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutTargetStrength (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamTargetStrength(int EmitterIndex, int TargetIndex, float* OutTargetStrength)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamTargetStrength");
|
|
|
|
UParticleSystemComponent_GetBeamTargetStrength_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.TargetIndex = TargetIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutTargetStrength != nullptr)
|
|
*OutTargetStrength = params.OutTargetStrength;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamTargetPoint
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TargetIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector OutTargetPoint (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamTargetPoint(int EmitterIndex, int TargetIndex, struct FVector* OutTargetPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamTargetPoint");
|
|
|
|
UParticleSystemComponent_GetBeamTargetPoint_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.TargetIndex = TargetIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutTargetPoint != nullptr)
|
|
*OutTargetPoint = params.OutTargetPoint;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamSourceTangent
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SourceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector OutTangentPoint (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamSourceTangent(int EmitterIndex, int SourceIndex, struct FVector* OutTangentPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamSourceTangent");
|
|
|
|
UParticleSystemComponent_GetBeamSourceTangent_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.SourceIndex = SourceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutTangentPoint != nullptr)
|
|
*OutTangentPoint = params.OutTangentPoint;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamSourceStrength
|
|
// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SourceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutSourceStrength (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamSourceStrength(int EmitterIndex, int SourceIndex, float* OutSourceStrength)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamSourceStrength");
|
|
|
|
UParticleSystemComponent_GetBeamSourceStrength_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.SourceIndex = SourceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutSourceStrength != nullptr)
|
|
*OutSourceStrength = params.OutSourceStrength;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamSourcePoint
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SourceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector OutSourcePoint (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamSourcePoint(int EmitterIndex, int SourceIndex, struct FVector* OutSourcePoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamSourcePoint");
|
|
|
|
UParticleSystemComponent_GetBeamSourcePoint_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
params.SourceIndex = SourceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutSourcePoint != nullptr)
|
|
*OutSourcePoint = params.OutSourcePoint;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GetBeamEndPoint
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int EmitterIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector OutEndPoint (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystemComponent::GetBeamEndPoint(int EmitterIndex, struct FVector* OutEndPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GetBeamEndPoint");
|
|
|
|
UParticleSystemComponent_GetBeamEndPoint_Params params;
|
|
params.EmitterIndex = EmitterIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutEndPoint != nullptr)
|
|
*OutEndPoint = params.OutEndPoint;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.GenerateParticleEvent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InEventName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InEmitterTime (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InLocation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector InDirection (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector InVelocity (ConstParm, Parm, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::GenerateParticleEvent(const struct FName& InEventName, float InEmitterTime, const struct FVector& InLocation, const struct FVector& InDirection, const struct FVector& InVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.GenerateParticleEvent");
|
|
|
|
UParticleSystemComponent_GenerateParticleEvent_Params params;
|
|
params.InEventName = InEventName;
|
|
params.InEmitterTime = InEmitterTime;
|
|
params.InLocation = InLocation;
|
|
params.InDirection = InDirection;
|
|
params.InVelocity = InVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.EndTrails
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UParticleSystemComponent::EndTrails()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.EndTrails");
|
|
|
|
UParticleSystemComponent_EndTrails_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.CreateNamedDynamicMaterialInstance
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* SourceMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UParticleSystemComponent::CreateNamedDynamicMaterialInstance(const struct FName& InName, class UMaterialInterface* SourceMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.CreateNamedDynamicMaterialInstance");
|
|
|
|
UParticleSystemComponent_CreateNamedDynamicMaterialInstance_Params params;
|
|
params.InName = InName;
|
|
params.SourceMaterial = SourceMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystemComponent.BeginTrails
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InFirstSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName InSecondSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETrailWidthMode> InWidthMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UParticleSystemComponent::BeginTrails(const struct FName& InFirstSocketName, const struct FName& InSecondSocketName, TEnumAsByte<ETrailWidthMode> InWidthMode, float InWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystemComponent.BeginTrails");
|
|
|
|
UParticleSystemComponent_BeginTrails_Params params;
|
|
params.InFirstSocketName = InFirstSocketName;
|
|
params.InSecondSocketName = InSecondSocketName;
|
|
params.InWidthMode = InWidthMode;
|
|
params.InWidth = InWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SpringArmComponent.SetActive
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewActive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bReset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpringArmComponent::SetActive(bool bNewActive, bool bReset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SpringArmComponent.SetActive");
|
|
|
|
USpringArmComponent_SetActive_Params params;
|
|
params.bNewActive = bNewActive;
|
|
params.bReset = bReset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SpringArmComponent.GetTargetRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USpringArmComponent::GetTargetRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SpringArmComponent.GetTargetRotation");
|
|
|
|
USpringArmComponent_GetTargetRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.WasInputKeyJustReleased
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::WasInputKeyJustReleased(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.WasInputKeyJustReleased");
|
|
|
|
APlayerController_WasInputKeyJustReleased_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.WasInputKeyJustPressed
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::WasInputKeyJustPressed(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.WasInputKeyJustPressed");
|
|
|
|
APlayerController_WasInputKeyJustPressed_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ToggleSpeaking
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// bool bInSpeaking (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ToggleSpeaking(bool bInSpeaking)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ToggleSpeaking");
|
|
|
|
APlayerController_ToggleSpeaking_Params params;
|
|
params.bInSpeaking = bInSpeaking;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SwitchLevel
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
|
|
void APlayerController::SwitchLevel(const struct FString& URL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SwitchLevel");
|
|
|
|
APlayerController_SwitchLevel_Params params;
|
|
params.URL = URL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.StopHapticEffect
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EControllerHand Hand (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::StopHapticEffect(EControllerHand Hand)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.StopHapticEffect");
|
|
|
|
APlayerController_StopHapticEffect_Params params;
|
|
params.Hand = Hand;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.StartFire
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// unsigned char FireModeNum (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::StartFire(unsigned char FireModeNum)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.StartFire");
|
|
|
|
APlayerController_StartFire_Params params;
|
|
params.FireModeNum = FireModeNum;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetVirtualJoystickVisibility
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bVisible (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::SetVirtualJoystickVisibility(bool bVisible)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetVirtualJoystickVisibility");
|
|
|
|
APlayerController_SetVirtualJoystickVisibility_Params params;
|
|
params.bVisible = bVisible;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetViewTargetWithBlend
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* NewViewTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float blendTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EViewTargetBlendFunction> BlendFunc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendExp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLockOutgoing (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::SetViewTargetWithBlend(class AActor* NewViewTarget, float blendTime, TEnumAsByte<EViewTargetBlendFunction> BlendFunc, float BlendExp, bool bLockOutgoing)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetViewTargetWithBlend");
|
|
|
|
APlayerController_SetViewTargetWithBlend_Params params;
|
|
params.NewViewTarget = NewViewTarget;
|
|
params.blendTime = blendTime;
|
|
params.BlendFunc = BlendFunc;
|
|
params.BlendExp = BlendExp;
|
|
params.bLockOutgoing = bLockOutgoing;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetName
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString S (Parm, ZeroConstructor)
|
|
|
|
void APlayerController::SetName(const struct FString& S)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetName");
|
|
|
|
APlayerController_SetName_Params params;
|
|
params.S = S;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetMouseLocation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int X (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Y (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::SetMouseLocation(int X, int Y)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetMouseLocation");
|
|
|
|
APlayerController_SetMouseLocation_Params params;
|
|
params.X = X;
|
|
params.Y = Y;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetMouseCursorWidget
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EMouseCursor> Cursor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UUserWidget* CursorWidget (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void APlayerController::SetMouseCursorWidget(TEnumAsByte<EMouseCursor> Cursor, class UUserWidget* CursorWidget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetMouseCursorWidget");
|
|
|
|
APlayerController_SetMouseCursorWidget_Params params;
|
|
params.Cursor = Cursor;
|
|
params.CursorWidget = CursorWidget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetHapticsByValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Frequency (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Amplitude (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// EControllerHand Hand (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::SetHapticsByValue(float Frequency, float Amplitude, EControllerHand Hand)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetHapticsByValue");
|
|
|
|
APlayerController_SetHapticsByValue_Params params;
|
|
params.Frequency = Frequency;
|
|
params.Amplitude = Amplitude;
|
|
params.Hand = Hand;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetControllerLightColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FColor Color (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::SetControllerLightColor(const struct FColor& Color)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetControllerLightColor");
|
|
|
|
APlayerController_SetControllerLightColor_Params params;
|
|
params.Color = Color;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetCinematicMode
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInCinematicMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHidePlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsHUD (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsTurning (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::SetCinematicMode(bool bInCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetCinematicMode");
|
|
|
|
APlayerController_SetCinematicMode_Params params;
|
|
params.bInCinematicMode = bInCinematicMode;
|
|
params.bHidePlayer = bHidePlayer;
|
|
params.bAffectsHUD = bAffectsHUD;
|
|
params.bAffectsMovement = bAffectsMovement;
|
|
params.bAffectsTurning = bAffectsTurning;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SetAudioListenerOverride
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::SetAudioListenerOverride(class USceneComponent* AttachToComponent, const struct FVector& Location, const struct FRotator& Rotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SetAudioListenerOverride");
|
|
|
|
APlayerController_SetAudioListenerOverride_Params params;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerViewSelf
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FViewTargetTransitionParams TransitionParams (Parm)
|
|
|
|
void APlayerController::ServerViewSelf(const struct FViewTargetTransitionParams& TransitionParams)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerViewSelf");
|
|
|
|
APlayerController_ServerViewSelf_Params params;
|
|
params.TransitionParams = TransitionParams;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerViewPrevPlayer
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerViewPrevPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerViewPrevPlayer");
|
|
|
|
APlayerController_ServerViewPrevPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerViewNextPlayer
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerViewNextPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerViewNextPlayer");
|
|
|
|
APlayerController_ServerViewNextPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerVerifyViewTarget
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerVerifyViewTarget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerVerifyViewTarget");
|
|
|
|
APlayerController_ServerVerifyViewTarget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerUpdateLevelVisibility
|
|
// (Final, Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FName PackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsVisible (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ServerUpdateLevelVisibility(const struct FName& PackageName, bool bIsVisible)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerUpdateLevelVisibility");
|
|
|
|
APlayerController_ServerUpdateLevelVisibility_Params params;
|
|
params.PackageName = PackageName;
|
|
params.bIsVisible = bIsVisible;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerUpdateCamera
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FVector_NetQuantize CamLoc (Parm)
|
|
// int CamPitchAndYaw (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ServerUpdateCamera(const struct FVector_NetQuantize& CamLoc, int CamPitchAndYaw)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerUpdateCamera");
|
|
|
|
APlayerController_ServerUpdateCamera_Params params;
|
|
params.CamLoc = CamLoc;
|
|
params.CamPitchAndYaw = CamPitchAndYaw;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerUnmutePlayer
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl PlayerID (Parm)
|
|
|
|
void APlayerController::ServerUnmutePlayer(const struct FUniqueNetIdRepl& PlayerID)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerUnmutePlayer");
|
|
|
|
APlayerController_ServerUnmutePlayer_Params params;
|
|
params.PlayerID = PlayerID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerToggleAILogging
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerToggleAILogging()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerToggleAILogging");
|
|
|
|
APlayerController_ServerToggleAILogging_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerShortTimeout
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerShortTimeout()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerShortTimeout");
|
|
|
|
APlayerController_ServerShortTimeout_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerSetSpectatorWaiting
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// bool bWaiting (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ServerSetSpectatorWaiting(bool bWaiting)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerSetSpectatorWaiting");
|
|
|
|
APlayerController_ServerSetSpectatorWaiting_Params params;
|
|
params.bWaiting = bWaiting;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerSetSpectatorLocation
|
|
// (Net, Native, Event, Public, NetServer, HasDefaults, NetValidate)
|
|
// Parameters:
|
|
// struct FVector NewLoc (Parm, IsPlainOldData)
|
|
// struct FRotator NewRot (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::ServerSetSpectatorLocation(const struct FVector& NewLoc, const struct FRotator& NewRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerSetSpectatorLocation");
|
|
|
|
APlayerController_ServerSetSpectatorLocation_Params params;
|
|
params.NewLoc = NewLoc;
|
|
params.NewRot = NewRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerRestartPlayer
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerRestartPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerRestartPlayer");
|
|
|
|
APlayerController_ServerRestartPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerPause
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerPause()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerPause");
|
|
|
|
APlayerController_ServerPause_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerNotifyLoadedWorld
|
|
// (Final, Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FName WorldPackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ServerNotifyLoadedWorld(const struct FName& WorldPackageName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerNotifyLoadedWorld");
|
|
|
|
APlayerController_ServerNotifyLoadedWorld_Params params;
|
|
params.WorldPackageName = WorldPackageName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerMutePlayer
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl PlayerID (Parm)
|
|
|
|
void APlayerController::ServerMutePlayer(const struct FUniqueNetIdRepl& PlayerID)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerMutePlayer");
|
|
|
|
APlayerController_ServerMutePlayer_Params params;
|
|
params.PlayerID = PlayerID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerCheckClientPossessionReliable
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerCheckClientPossessionReliable()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerCheckClientPossessionReliable");
|
|
|
|
APlayerController_ServerCheckClientPossessionReliable_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerCheckClientPossession
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void APlayerController::ServerCheckClientPossession()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerCheckClientPossession");
|
|
|
|
APlayerController_ServerCheckClientPossession_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerChangeName
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FString S (Parm, ZeroConstructor)
|
|
|
|
void APlayerController::ServerChangeName(const struct FString& S)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerChangeName");
|
|
|
|
APlayerController_ServerChangeName_Params params;
|
|
params.S = S;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerCamera
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// struct FName NewMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ServerCamera(const struct FName& NewMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerCamera");
|
|
|
|
APlayerController_ServerCamera_Params params;
|
|
params.NewMode = NewMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ServerAcknowledgePossession
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// class APawn* P (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ServerAcknowledgePossession(class APawn* P)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ServerAcknowledgePossession");
|
|
|
|
APlayerController_ServerAcknowledgePossession_Params params;
|
|
params.P = P;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.SendToConsole
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString Command (Parm, ZeroConstructor)
|
|
|
|
void APlayerController::SendToConsole(const struct FString& Command)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.SendToConsole");
|
|
|
|
APlayerController_SendToConsole_Params params;
|
|
params.Command = Command;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.RestartLevel
|
|
// (Exec, Native, Public)
|
|
|
|
void APlayerController::RestartLevel()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.RestartLevel");
|
|
|
|
APlayerController_RestartLevel_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ProjectWorldLocationToScreen
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenLocation (Parm, OutParm, IsPlainOldData)
|
|
// bool bPlayerViewportRelative (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::ProjectWorldLocationToScreen(const struct FVector& WorldLocation, bool bPlayerViewportRelative, struct FVector2D* ScreenLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ProjectWorldLocationToScreen");
|
|
|
|
APlayerController_ProjectWorldLocationToScreen_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.bPlayerViewportRelative = bPlayerViewportRelative;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ScreenLocation != nullptr)
|
|
*ScreenLocation = params.ScreenLocation;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.PlayHapticEffect
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UHapticFeedbackEffect_Base* HapticEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EControllerHand Hand (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLoop (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::PlayHapticEffect(class UHapticFeedbackEffect_Base* HapticEffect, EControllerHand Hand, float Scale, bool bLoop)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.PlayHapticEffect");
|
|
|
|
APlayerController_PlayHapticEffect_Params params;
|
|
params.HapticEffect = HapticEffect;
|
|
params.Hand = Hand;
|
|
params.Scale = Scale;
|
|
params.bLoop = bLoop;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.PlayDynamicForceFeedback
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Intensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsLeftLarge (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsLeftSmall (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsRightLarge (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsRightSmall (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EDynamicForceFeedbackAction> Action (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void APlayerController::PlayDynamicForceFeedback(float Intensity, float Duration, bool bAffectsLeftLarge, bool bAffectsLeftSmall, bool bAffectsRightLarge, bool bAffectsRightSmall, TEnumAsByte<EDynamicForceFeedbackAction> Action, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.PlayDynamicForceFeedback");
|
|
|
|
APlayerController_PlayDynamicForceFeedback_Params params;
|
|
params.Intensity = Intensity;
|
|
params.Duration = Duration;
|
|
params.bAffectsLeftLarge = bAffectsLeftLarge;
|
|
params.bAffectsLeftSmall = bAffectsLeftSmall;
|
|
params.bAffectsRightLarge = bAffectsRightLarge;
|
|
params.bAffectsRightSmall = bAffectsRightSmall;
|
|
params.Action = Action;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.Pause
|
|
// (Exec, Native, Public)
|
|
|
|
void APlayerController::Pause()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.Pause");
|
|
|
|
APlayerController_Pause_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.OnServerStartedVisualLogger
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// bool bIsLogging (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::OnServerStartedVisualLogger(bool bIsLogging)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.OnServerStartedVisualLogger");
|
|
|
|
APlayerController_OnServerStartedVisualLogger_Params params;
|
|
params.bIsLogging = bIsLogging;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.LocalTravel
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
|
|
void APlayerController::LocalTravel(const struct FString& URL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.LocalTravel");
|
|
|
|
APlayerController_LocalTravel_Params params;
|
|
params.URL = URL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.IsInputKeyDown
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::IsInputKeyDown(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.IsInputKeyDown");
|
|
|
|
APlayerController_IsInputKeyDown_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetViewportSize
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int SizeX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int SizeY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::GetViewportSize(int* SizeX, int* SizeY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetViewportSize");
|
|
|
|
APlayerController_GetViewportSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SizeX != nullptr)
|
|
*SizeX = params.SizeX;
|
|
if (SizeY != nullptr)
|
|
*SizeY = params.SizeY;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetSpectatorPawn
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class ASpectatorPawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ASpectatorPawn* APlayerController::GetSpectatorPawn()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetSpectatorPawn");
|
|
|
|
APlayerController_GetSpectatorPawn_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetMousePosition
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float LocationX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetMousePosition(float* LocationX, float* LocationY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetMousePosition");
|
|
|
|
APlayerController_GetMousePosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LocationX != nullptr)
|
|
*LocationX = params.LocationX;
|
|
if (LocationY != nullptr)
|
|
*LocationY = params.LocationY;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputVectorKeyState
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APlayerController::GetInputVectorKeyState(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputVectorKeyState");
|
|
|
|
APlayerController_GetInputVectorKeyState_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputTouchState
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsCurrentlyPressed (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::GetInputTouchState(TEnumAsByte<ETouchIndex> FingerIndex, float* LocationX, float* LocationY, bool* bIsCurrentlyPressed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputTouchState");
|
|
|
|
APlayerController_GetInputTouchState_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LocationX != nullptr)
|
|
*LocationX = params.LocationX;
|
|
if (LocationY != nullptr)
|
|
*LocationY = params.LocationY;
|
|
if (bIsCurrentlyPressed != nullptr)
|
|
*bIsCurrentlyPressed = params.bIsCurrentlyPressed;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputMouseDelta
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float DeltaX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float DeltaY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::GetInputMouseDelta(float* DeltaX, float* DeltaY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputMouseDelta");
|
|
|
|
APlayerController_GetInputMouseDelta_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (DeltaX != nullptr)
|
|
*DeltaX = params.DeltaX;
|
|
if (DeltaY != nullptr)
|
|
*DeltaY = params.DeltaY;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputMotionState
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Tilt (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector RotationRate (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Gravity (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Acceleration (Parm, OutParm, IsPlainOldData)
|
|
|
|
void APlayerController::GetInputMotionState(struct FVector* Tilt, struct FVector* RotationRate, struct FVector* Gravity, struct FVector* Acceleration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputMotionState");
|
|
|
|
APlayerController_GetInputMotionState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Tilt != nullptr)
|
|
*Tilt = params.Tilt;
|
|
if (RotationRate != nullptr)
|
|
*RotationRate = params.RotationRate;
|
|
if (Gravity != nullptr)
|
|
*Gravity = params.Gravity;
|
|
if (Acceleration != nullptr)
|
|
*Acceleration = params.Acceleration;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputKeyTimeDown
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float APlayerController::GetInputKeyTimeDown(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputKeyTimeDown");
|
|
|
|
APlayerController_GetInputKeyTimeDown_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputAnalogStickState
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EControllerAnalogStick> WhichStick (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StickX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float StickY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::GetInputAnalogStickState(TEnumAsByte<EControllerAnalogStick> WhichStick, float* StickX, float* StickY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputAnalogStickState");
|
|
|
|
APlayerController_GetInputAnalogStickState_Params params;
|
|
params.WhichStick = WhichStick;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (StickX != nullptr)
|
|
*StickX = params.StickX;
|
|
if (StickY != nullptr)
|
|
*StickY = params.StickY;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetInputAnalogKeyState
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float APlayerController::GetInputAnalogKeyState(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetInputAnalogKeyState");
|
|
|
|
APlayerController_GetInputAnalogKeyState_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHUD
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AHUD* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AHUD* APlayerController::GetHUD()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHUD");
|
|
|
|
APlayerController_GetHUD_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHitResultUnderFingerForObjects
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetHitResultUnderFingerForObjects(TEnumAsByte<ETouchIndex> FingerIndex, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, struct FHitResult* HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHitResultUnderFingerForObjects");
|
|
|
|
APlayerController_GetHitResultUnderFingerForObjects_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitResult != nullptr)
|
|
*HitResult = params.HitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHitResultUnderFingerByChannel
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetHitResultUnderFingerByChannel(TEnumAsByte<ETouchIndex> FingerIndex, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, struct FHitResult* HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHitResultUnderFingerByChannel");
|
|
|
|
APlayerController_GetHitResultUnderFingerByChannel_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitResult != nullptr)
|
|
*HitResult = params.HitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHitResultUnderFinger
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ETouchIndex> FingerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECollisionChannel> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetHitResultUnderFinger(TEnumAsByte<ETouchIndex> FingerIndex, TEnumAsByte<ECollisionChannel> TraceChannel, bool bTraceComplex, struct FHitResult* HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHitResultUnderFinger");
|
|
|
|
APlayerController_GetHitResultUnderFinger_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitResult != nullptr)
|
|
*HitResult = params.HitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHitResultUnderCursorForObjects
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetHitResultUnderCursorForObjects(TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, struct FHitResult* HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHitResultUnderCursorForObjects");
|
|
|
|
APlayerController_GetHitResultUnderCursorForObjects_Params params;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitResult != nullptr)
|
|
*HitResult = params.HitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHitResultUnderCursorByChannel
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetHitResultUnderCursorByChannel(TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, struct FHitResult* HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHitResultUnderCursorByChannel");
|
|
|
|
APlayerController_GetHitResultUnderCursorByChannel_Params params;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitResult != nullptr)
|
|
*HitResult = params.HitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetHitResultUnderCursor
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionChannel> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult HitResult (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::GetHitResultUnderCursor(TEnumAsByte<ECollisionChannel> TraceChannel, bool bTraceComplex, struct FHitResult* HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetHitResultUnderCursor");
|
|
|
|
APlayerController_GetHitResultUnderCursor_Params params;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitResult != nullptr)
|
|
*HitResult = params.HitResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.GetFocalLocation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APlayerController::GetFocalLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.GetFocalLocation");
|
|
|
|
APlayerController_GetFocalLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.FOV
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// float NewFOV (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::FOV(float NewFOV)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.FOV");
|
|
|
|
APlayerController_FOV_Params params;
|
|
params.NewFOV = NewFOV;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.EnableCheats
|
|
// (Exec, Native, Public)
|
|
|
|
void APlayerController::EnableCheats()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.EnableCheats");
|
|
|
|
APlayerController_EnableCheats_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.DeprojectScreenPositionToWorld
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector WorldLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector WorldDirection (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::DeprojectScreenPositionToWorld(float ScreenX, float ScreenY, struct FVector* WorldLocation, struct FVector* WorldDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.DeprojectScreenPositionToWorld");
|
|
|
|
APlayerController_DeprojectScreenPositionToWorld_Params params;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (WorldLocation != nullptr)
|
|
*WorldLocation = params.WorldLocation;
|
|
if (WorldDirection != nullptr)
|
|
*WorldDirection = params.WorldDirection;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.DeprojectMousePositionToWorld
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector WorldDirection (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerController::DeprojectMousePositionToWorld(struct FVector* WorldLocation, struct FVector* WorldDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.DeprojectMousePositionToWorld");
|
|
|
|
APlayerController_DeprojectMousePositionToWorld_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (WorldLocation != nullptr)
|
|
*WorldLocation = params.WorldLocation;
|
|
if (WorldDirection != nullptr)
|
|
*WorldDirection = params.WorldDirection;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ConsoleKey
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
|
|
void APlayerController::ConsoleKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ConsoleKey");
|
|
|
|
APlayerController_ConsoleKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientWasKicked
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FText KickReason (ConstParm, Parm, ReferenceParm)
|
|
|
|
void APlayerController::ClientWasKicked(const struct FText& KickReason)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientWasKicked");
|
|
|
|
APlayerController_ClientWasKicked_Params params;
|
|
params.KickReason = KickReason;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientVoiceHandshakeComplete
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientVoiceHandshakeComplete()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientVoiceHandshakeComplete");
|
|
|
|
APlayerController_ClientVoiceHandshakeComplete_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientUpdateLevelStreamingStatus
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FName PackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bNewShouldBeLoaded (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bNewShouldBeVisible (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bNewShouldBlockOnLoad (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientUpdateLevelStreamingStatus(const struct FName& PackageName, bool bNewShouldBeLoaded, bool bNewShouldBeVisible, bool bNewShouldBlockOnLoad, int LODIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientUpdateLevelStreamingStatus");
|
|
|
|
APlayerController_ClientUpdateLevelStreamingStatus_Params params;
|
|
params.PackageName = PackageName;
|
|
params.bNewShouldBeLoaded = bNewShouldBeLoaded;
|
|
params.bNewShouldBeVisible = bNewShouldBeVisible;
|
|
params.bNewShouldBlockOnLoad = bNewShouldBlockOnLoad;
|
|
params.LODIndex = LODIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientUnmutePlayer
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl PlayerID (Parm)
|
|
|
|
void APlayerController::ClientUnmutePlayer(const struct FUniqueNetIdRepl& PlayerID)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientUnmutePlayer");
|
|
|
|
APlayerController_ClientUnmutePlayer_Params params;
|
|
params.PlayerID = PlayerID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientTravelInternal
|
|
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ETravelType> TravelType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSeamless (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGuid MapPackageGuid (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::ClientTravelInternal(const struct FString& URL, TEnumAsByte<ETravelType> TravelType, bool bSeamless, const struct FGuid& MapPackageGuid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientTravelInternal");
|
|
|
|
APlayerController_ClientTravelInternal_Params params;
|
|
params.URL = URL;
|
|
params.TravelType = TravelType;
|
|
params.bSeamless = bSeamless;
|
|
params.MapPackageGuid = MapPackageGuid;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientTravel
|
|
// (Final, Native, Public, HasDefaults)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ETravelType> TravelType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSeamless (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGuid MapPackageGuid (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::ClientTravel(const struct FString& URL, TEnumAsByte<ETravelType> TravelType, bool bSeamless, const struct FGuid& MapPackageGuid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientTravel");
|
|
|
|
APlayerController_ClientTravel_Params params;
|
|
params.URL = URL;
|
|
params.TravelType = TravelType;
|
|
params.bSeamless = bSeamless;
|
|
params.MapPackageGuid = MapPackageGuid;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientTeamMessage
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class APlayerState* SenderPlayerState (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString S (Parm, ZeroConstructor)
|
|
// struct FName Type (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MsgLifeTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientTeamMessage(class APlayerState* SenderPlayerState, const struct FString& S, const struct FName& Type, float MsgLifeTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientTeamMessage");
|
|
|
|
APlayerController_ClientTeamMessage_Params params;
|
|
params.SenderPlayerState = SenderPlayerState;
|
|
params.S = S;
|
|
params.Type = Type;
|
|
params.MsgLifeTime = MsgLifeTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientStopForceFeedback
|
|
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UForceFeedbackEffect* ForceFeedbackEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientStopForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, const struct FName& Tag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientStopForceFeedback");
|
|
|
|
APlayerController_ClientStopForceFeedback_Params params;
|
|
params.ForceFeedbackEffect = ForceFeedbackEffect;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientStopCameraShake
|
|
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* Shake (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bImmediately (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientStopCameraShake(class UClass* Shake, bool bImmediately)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientStopCameraShake");
|
|
|
|
APlayerController_ClientStopCameraShake_Params params;
|
|
params.Shake = Shake;
|
|
params.bImmediately = bImmediately;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientStopCameraAnim
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class UCameraAnim* AnimToStop (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientStopCameraAnim(class UCameraAnim* AnimToStop)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientStopCameraAnim");
|
|
|
|
APlayerController_ClientStopCameraAnim_Params params;
|
|
params.AnimToStop = AnimToStop;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientStartOnlineSession
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientStartOnlineSession()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientStartOnlineSession");
|
|
|
|
APlayerController_ClientStartOnlineSession_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSpawnCameraLensEffect
|
|
// (Net, Native, Event, Public, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* LensEffectEmitterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSpawnCameraLensEffect(class UClass* LensEffectEmitterClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSpawnCameraLensEffect");
|
|
|
|
APlayerController_ClientSpawnCameraLensEffect_Params params;
|
|
params.LensEffectEmitterClass = LensEffectEmitterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetViewTarget
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class AActor* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FViewTargetTransitionParams TransitionParams (Parm)
|
|
|
|
void APlayerController::ClientSetViewTarget(class AActor* A, const struct FViewTargetTransitionParams& TransitionParams)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetViewTarget");
|
|
|
|
APlayerController_ClientSetViewTarget_Params params;
|
|
params.A = A;
|
|
params.TransitionParams = TransitionParams;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetSpectatorWaiting
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// bool bWaiting (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSetSpectatorWaiting(bool bWaiting)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetSpectatorWaiting");
|
|
|
|
APlayerController_ClientSetSpectatorWaiting_Params params;
|
|
params.bWaiting = bWaiting;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetHUD
|
|
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* NewHUDClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSetHUD(class UClass* NewHUDClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetHUD");
|
|
|
|
APlayerController_ClientSetHUD_Params params;
|
|
params.NewHUDClass = NewHUDClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetForceMipLevelsToBeResident
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ForceDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int CinematicTextureGroups (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSetForceMipLevelsToBeResident(class UMaterialInterface* Material, float ForceDuration, int CinematicTextureGroups)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetForceMipLevelsToBeResident");
|
|
|
|
APlayerController_ClientSetForceMipLevelsToBeResident_Params params;
|
|
params.Material = Material;
|
|
params.ForceDuration = ForceDuration;
|
|
params.CinematicTextureGroups = CinematicTextureGroups;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetCinematicMode
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// bool bInCinematicMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsTurning (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsHUD (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSetCinematicMode(bool bInCinematicMode, bool bAffectsMovement, bool bAffectsTurning, bool bAffectsHUD)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetCinematicMode");
|
|
|
|
APlayerController_ClientSetCinematicMode_Params params;
|
|
params.bInCinematicMode = bInCinematicMode;
|
|
params.bAffectsMovement = bAffectsMovement;
|
|
params.bAffectsTurning = bAffectsTurning;
|
|
params.bAffectsHUD = bAffectsHUD;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetCameraMode
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FName NewCamMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSetCameraMode(const struct FName& NewCamMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetCameraMode");
|
|
|
|
APlayerController_ClientSetCameraMode_Params params;
|
|
params.NewCamMode = NewCamMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetCameraFade
|
|
// (Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// bool bEnableFading (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FColor FadeColor (Parm, IsPlainOldData)
|
|
// struct FVector2D FadeAlpha (Parm, IsPlainOldData)
|
|
// float FadeTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFadeAudio (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientSetCameraFade(bool bEnableFading, const struct FColor& FadeColor, const struct FVector2D& FadeAlpha, float FadeTime, bool bFadeAudio)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetCameraFade");
|
|
|
|
APlayerController_ClientSetCameraFade_Params params;
|
|
params.bEnableFading = bEnableFading;
|
|
params.FadeColor = FadeColor;
|
|
params.FadeAlpha = FadeAlpha;
|
|
params.FadeTime = FadeTime;
|
|
params.bFadeAudio = bFadeAudio;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientSetBlockOnAsyncLoading
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientSetBlockOnAsyncLoading()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientSetBlockOnAsyncLoading");
|
|
|
|
APlayerController_ClientSetBlockOnAsyncLoading_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientReturnToMainMenu
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FString ReturnReason (Parm, ZeroConstructor)
|
|
|
|
void APlayerController::ClientReturnToMainMenu(const struct FString& ReturnReason)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientReturnToMainMenu");
|
|
|
|
APlayerController_ClientReturnToMainMenu_Params params;
|
|
params.ReturnReason = ReturnReason;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientRetryClientRestart
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class APawn* NewPawn (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientRetryClientRestart(class APawn* NewPawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientRetryClientRestart");
|
|
|
|
APlayerController_ClientRetryClientRestart_Params params;
|
|
params.NewPawn = NewPawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientRestart
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class APawn* NewPawn (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientRestart(class APawn* NewPawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientRestart");
|
|
|
|
APlayerController_ClientRestart_Params params;
|
|
params.NewPawn = NewPawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientReset
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientReset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientReset");
|
|
|
|
APlayerController_ClientReset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientRepObjRef
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientRepObjRef(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientRepObjRef");
|
|
|
|
APlayerController_ClientRepObjRef_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientReceiveLocalizedMessage
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class UClass* Message (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Switch (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerState* RelatedPlayerState_2 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerState* RelatedPlayerState_3 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* OptionalObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientReceiveLocalizedMessage(class UClass* Message, int Switch, class APlayerState* RelatedPlayerState_2, class APlayerState* RelatedPlayerState_3, class UObject* OptionalObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientReceiveLocalizedMessage");
|
|
|
|
APlayerController_ClientReceiveLocalizedMessage_Params params;
|
|
params.Message = Message;
|
|
params.Switch = Switch;
|
|
params.RelatedPlayerState_2 = RelatedPlayerState_2;
|
|
params.RelatedPlayerState_3 = RelatedPlayerState_3;
|
|
params.OptionalObject = OptionalObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPrestreamTextures
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class AActor* ForcedActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ForceDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableStreaming (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int CinematicTextureGroups (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPrestreamTextures(class AActor* ForcedActor, float ForceDuration, bool bEnableStreaming, int CinematicTextureGroups)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPrestreamTextures");
|
|
|
|
APlayerController_ClientPrestreamTextures_Params params;
|
|
params.ForcedActor = ForcedActor;
|
|
params.ForceDuration = ForceDuration;
|
|
params.bEnableStreaming = bEnableStreaming;
|
|
params.CinematicTextureGroups = CinematicTextureGroups;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPrepareMapChange
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FName LevelName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFirst (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLast (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPrepareMapChange(const struct FName& LevelName, bool bFirst, bool bLast)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPrepareMapChange");
|
|
|
|
APlayerController_ClientPrepareMapChange_Params params;
|
|
params.LevelName = LevelName;
|
|
params.bFirst = bFirst;
|
|
params.bLast = bLast;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPlaySoundAtLocation
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPlaySoundAtLocation(class USoundBase* Sound, const struct FVector& Location, float VolumeMultiplier, float PitchMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPlaySoundAtLocation");
|
|
|
|
APlayerController_ClientPlaySoundAtLocation_Params params;
|
|
params.Sound = Sound;
|
|
params.Location = Location;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPlaySound
|
|
// (Net, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPlaySound(class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPlaySound");
|
|
|
|
APlayerController_ClientPlaySound_Params params;
|
|
params.Sound = Sound;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPlayForceFeedback
|
|
// (Net, Native, Event, Public, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UForceFeedbackEffect* ForceFeedbackEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIgnoreTimeDilation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPlayForceFeedback(class UForceFeedbackEffect* ForceFeedbackEffect, bool bLooping, bool bIgnoreTimeDilation, const struct FName& Tag)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPlayForceFeedback");
|
|
|
|
APlayerController_ClientPlayForceFeedback_Params params;
|
|
params.ForceFeedbackEffect = ForceFeedbackEffect;
|
|
params.bLooping = bLooping;
|
|
params.bIgnoreTimeDilation = bIgnoreTimeDilation;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPlayCameraShake
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* Shake (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECameraAnimPlaySpace> PlaySpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator UserPlaySpaceRot (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPlayCameraShake(class UClass* Shake, float Scale, TEnumAsByte<ECameraAnimPlaySpace> PlaySpace, const struct FRotator& UserPlaySpaceRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPlayCameraShake");
|
|
|
|
APlayerController_ClientPlayCameraShake_Params params;
|
|
params.Shake = Shake;
|
|
params.Scale = Scale;
|
|
params.PlaySpace = PlaySpace;
|
|
params.UserPlaySpaceRot = UserPlaySpaceRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientPlayCameraAnim
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCameraAnim* AnimToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Rate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendInTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLoop (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRandomStartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECameraAnimPlaySpace> Space (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator CustomPlaySpace (Parm, IsPlainOldData)
|
|
|
|
void APlayerController::ClientPlayCameraAnim(class UCameraAnim* AnimToPlay, float Scale, float Rate, float BlendInTime, float BlendOutTime, bool bLoop, bool bRandomStartTime, TEnumAsByte<ECameraAnimPlaySpace> Space, const struct FRotator& CustomPlaySpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientPlayCameraAnim");
|
|
|
|
APlayerController_ClientPlayCameraAnim_Params params;
|
|
params.AnimToPlay = AnimToPlay;
|
|
params.Scale = Scale;
|
|
params.Rate = Rate;
|
|
params.BlendInTime = BlendInTime;
|
|
params.BlendOutTime = BlendOutTime;
|
|
params.bLoop = bLoop;
|
|
params.bRandomStartTime = bRandomStartTime;
|
|
params.Space = Space;
|
|
params.CustomPlaySpace = CustomPlaySpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientMutePlayer
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FUniqueNetIdRepl PlayerID (Parm)
|
|
|
|
void APlayerController::ClientMutePlayer(const struct FUniqueNetIdRepl& PlayerID)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientMutePlayer");
|
|
|
|
APlayerController_ClientMutePlayer_Params params;
|
|
params.PlayerID = PlayerID;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientMessage
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FString S (Parm, ZeroConstructor)
|
|
// struct FName Type (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MsgLifeTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientMessage(const struct FString& S, const struct FName& Type, float MsgLifeTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientMessage");
|
|
|
|
APlayerController_ClientMessage_Params params;
|
|
params.S = S;
|
|
params.Type = Type;
|
|
params.MsgLifeTime = MsgLifeTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientIgnoreMoveInput
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// bool bIgnore (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientIgnoreMoveInput(bool bIgnore)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientIgnoreMoveInput");
|
|
|
|
APlayerController_ClientIgnoreMoveInput_Params params;
|
|
params.bIgnore = bIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientIgnoreLookInput
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// bool bIgnore (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientIgnoreLookInput(bool bIgnore)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientIgnoreLookInput");
|
|
|
|
APlayerController_ClientIgnoreLookInput_Params params;
|
|
params.bIgnore = bIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientGotoState
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FName NewState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientGotoState(const struct FName& NewState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientGotoState");
|
|
|
|
APlayerController_ClientGotoState_Params params;
|
|
params.NewState = NewState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientGameEnded
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class AActor* EndGameFocus (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsWinner (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientGameEnded(class AActor* EndGameFocus, bool bIsWinner)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientGameEnded");
|
|
|
|
APlayerController_ClientGameEnded_Params params;
|
|
params.EndGameFocus = EndGameFocus;
|
|
params.bIsWinner = bIsWinner;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientForceGarbageCollection
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientForceGarbageCollection()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientForceGarbageCollection");
|
|
|
|
APlayerController_ClientForceGarbageCollection_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientFlushLevelStreaming
|
|
// (Final, Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientFlushLevelStreaming()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientFlushLevelStreaming");
|
|
|
|
APlayerController_ClientFlushLevelStreaming_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientEndOnlineSession
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientEndOnlineSession()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientEndOnlineSession");
|
|
|
|
APlayerController_ClientEndOnlineSession_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientEnableNetworkVoice
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientEnableNetworkVoice(bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientEnableNetworkVoice");
|
|
|
|
APlayerController_ClientEnableNetworkVoice_Params params;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientCommitMapChange
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientCommitMapChange()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientCommitMapChange");
|
|
|
|
APlayerController_ClientCommitMapChange_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientClearCameraLensEffects
|
|
// (Net, NetReliable, Native, Event, Public, NetClient, BlueprintCallable)
|
|
|
|
void APlayerController::ClientClearCameraLensEffects()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientClearCameraLensEffects");
|
|
|
|
APlayerController_ClientClearCameraLensEffects_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientCapBandwidth
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// int Cap (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientCapBandwidth(int Cap)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientCapBandwidth");
|
|
|
|
APlayerController_ClientCapBandwidth_Params params;
|
|
params.Cap = Cap;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientCancelPendingMapChange
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void APlayerController::ClientCancelPendingMapChange()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientCancelPendingMapChange");
|
|
|
|
APlayerController_ClientCancelPendingMapChange_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClientAddTextureStreamingLoc
|
|
// (Final, Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// struct FVector InLoc (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bOverrideLocation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ClientAddTextureStreamingLoc(const struct FVector& InLoc, float Duration, bool bOverrideLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClientAddTextureStreamingLoc");
|
|
|
|
APlayerController_ClientAddTextureStreamingLoc_Params params;
|
|
params.InLoc = InLoc;
|
|
params.Duration = Duration;
|
|
params.bOverrideLocation = bOverrideLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ClearAudioListenerOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void APlayerController::ClearAudioListenerOverride()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ClearAudioListenerOverride");
|
|
|
|
APlayerController_ClearAudioListenerOverride_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.Camera
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName NewMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::Camera(const struct FName& NewMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.Camera");
|
|
|
|
APlayerController_Camera_Params params;
|
|
params.NewMode = NewMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.AddYawInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::AddYawInput(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.AddYawInput");
|
|
|
|
APlayerController_AddYawInput_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.AddRollInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::AddRollInput(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.AddRollInput");
|
|
|
|
APlayerController_AddRollInput_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.AddPitchInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::AddPitchInput(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.AddPitchInput");
|
|
|
|
APlayerController_AddPitchInput_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerController.ActivateTouchInterface
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTouchInterface* NewTouchInterface (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerController::ActivateTouchInterface(class UTouchInterface* NewTouchInterface)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerController.ActivateTouchInterface");
|
|
|
|
APlayerController_ActivateTouchInterface_Params params;
|
|
params.NewTouchInterface = NewTouchInterface;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.Walk
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::Walk()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.Walk");
|
|
|
|
UCheatManager_Walk_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ViewSelf
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::ViewSelf()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ViewSelf");
|
|
|
|
UCheatManager_ViewSelf_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ViewPlayer
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString S (Parm, ZeroConstructor)
|
|
|
|
void UCheatManager::ViewPlayer(const struct FString& S)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ViewPlayer");
|
|
|
|
UCheatManager_ViewPlayer_Params params;
|
|
params.S = S;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ViewClass
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// class UClass* DesiredClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::ViewClass(class UClass* DesiredClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ViewClass");
|
|
|
|
UCheatManager_ViewClass_Params params;
|
|
params.DesiredClass = DesiredClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ViewActor
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName ActorName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::ViewActor(const struct FName& ActorName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ViewActor");
|
|
|
|
UCheatManager_ViewActor_Params params;
|
|
params.ActorName = ActorName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ToggleDebugCamera
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::ToggleDebugCamera()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ToggleDebugCamera");
|
|
|
|
UCheatManager_ToggleDebugCamera_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ToggleAILogging
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::ToggleAILogging()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ToggleAILogging");
|
|
|
|
UCheatManager_ToggleAILogging_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.TestCollisionDistance
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::TestCollisionDistance()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.TestCollisionDistance");
|
|
|
|
UCheatManager_TestCollisionDistance_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.Teleport
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::Teleport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.Teleport");
|
|
|
|
UCheatManager_Teleport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.Summon
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString ClassName (Parm, ZeroConstructor)
|
|
|
|
void UCheatManager::Summon(const struct FString& ClassName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.Summon");
|
|
|
|
UCheatManager_Summon_Params params;
|
|
params.ClassName = ClassName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.StreamLevelOut
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName PackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::StreamLevelOut(const struct FName& PackageName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.StreamLevelOut");
|
|
|
|
UCheatManager_StreamLevelOut_Params params;
|
|
params.PackageName = PackageName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.StreamLevelIn
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName PackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::StreamLevelIn(const struct FName& PackageName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.StreamLevelIn");
|
|
|
|
UCheatManager_StreamLevelIn_Params params;
|
|
params.PackageName = PackageName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.Slomo
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewTimeDilation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::Slomo(float NewTimeDilation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.Slomo");
|
|
|
|
UCheatManager_Slomo_Params params;
|
|
params.NewTimeDilation = NewTimeDilation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.SetWorldOrigin
|
|
// (Final, Exec, Native, Public)
|
|
|
|
void UCheatManager::SetWorldOrigin()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.SetWorldOrigin");
|
|
|
|
UCheatManager_SetWorldOrigin_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.SetNavDrawDistance
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// float DrawDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::SetNavDrawDistance(float DrawDistance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.SetNavDrawDistance");
|
|
|
|
UCheatManager_SetNavDrawDistance_Params params;
|
|
params.DrawDistance = DrawDistance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.SetMouseSensitivityToDefault
|
|
// (Final, Exec, Native, Public)
|
|
|
|
void UCheatManager::SetMouseSensitivityToDefault()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.SetMouseSensitivityToDefault");
|
|
|
|
UCheatManager_SetMouseSensitivityToDefault_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ServerToggleAILogging
|
|
// (Net, NetReliable, Native, Event, Public, NetServer, NetValidate)
|
|
|
|
void UCheatManager::ServerToggleAILogging()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ServerToggleAILogging");
|
|
|
|
UCheatManager_ServerToggleAILogging_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ReceiveInitCheatManager
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UCheatManager::ReceiveInitCheatManager()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ReceiveInitCheatManager");
|
|
|
|
UCheatManager_ReceiveInitCheatManager_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ReceiveEndPlay
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UCheatManager::ReceiveEndPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ReceiveEndPlay");
|
|
|
|
UCheatManager_ReceiveEndPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.RebuildNavigation
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::RebuildNavigation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.RebuildNavigation");
|
|
|
|
UCheatManager_RebuildNavigation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.PlayersOnly
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::PlayersOnly()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.PlayersOnly");
|
|
|
|
UCheatManager_PlayersOnly_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.OnlyLoadLevel
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName PackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::OnlyLoadLevel(const struct FName& PackageName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.OnlyLoadLevel");
|
|
|
|
UCheatManager_OnlyLoadLevel_Params params;
|
|
params.PackageName = PackageName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.LogLoc
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::LogLoc()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.LogLoc");
|
|
|
|
UCheatManager_LogLoc_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.InvertMouse
|
|
// (Final, Exec, Native, Public)
|
|
|
|
void UCheatManager::InvertMouse()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.InvertMouse");
|
|
|
|
UCheatManager_InvertMouse_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.God
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::God()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.God");
|
|
|
|
UCheatManager_God_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.Ghost
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::Ghost()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.Ghost");
|
|
|
|
UCheatManager_Ghost_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.FreezeFrame
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Delay (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::FreezeFrame(float Delay)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.FreezeFrame");
|
|
|
|
UCheatManager_FreezeFrame_Params params;
|
|
params.Delay = Delay;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.Fly
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::Fly()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.Fly");
|
|
|
|
UCheatManager_Fly_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.FlushLog
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::FlushLog()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.FlushLog");
|
|
|
|
UCheatManager_FlushLog_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.EnableDebugCamera
|
|
// (Native, Protected, BlueprintCallable)
|
|
|
|
void UCheatManager::EnableDebugCamera()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.EnableDebugCamera");
|
|
|
|
UCheatManager_EnableDebugCamera_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DumpVoiceMutingState
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DumpVoiceMutingState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DumpVoiceMutingState");
|
|
|
|
UCheatManager_DumpVoiceMutingState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DumpPartyState
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DumpPartyState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DumpPartyState");
|
|
|
|
UCheatManager_DumpPartyState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DumpOnlineSessionState
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DumpOnlineSessionState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DumpOnlineSessionState");
|
|
|
|
UCheatManager_DumpOnlineSessionState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DumpChatState
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DumpChatState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DumpChatState");
|
|
|
|
UCheatManager_DumpChatState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DisableDebugCamera
|
|
// (Native, Protected, BlueprintCallable)
|
|
|
|
void UCheatManager::DisableDebugCamera()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DisableDebugCamera");
|
|
|
|
UCheatManager_DisableDebugCamera_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DestroyTarget
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
|
|
void UCheatManager::DestroyTarget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DestroyTarget");
|
|
|
|
UCheatManager_DestroyTarget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DestroyPawns
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// class UClass* aClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::DestroyPawns(class UClass* aClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DestroyPawns");
|
|
|
|
UCheatManager_DestroyPawns_Params params;
|
|
params.aClass = aClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DestroyAllPawnsExceptTarget
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DestroyAllPawnsExceptTarget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DestroyAllPawnsExceptTarget");
|
|
|
|
UCheatManager_DestroyAllPawnsExceptTarget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DestroyAll
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// class UClass* aClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::DestroyAll(class UClass* aClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DestroyAll");
|
|
|
|
UCheatManager_DestroyAll_Params params;
|
|
params.aClass = aClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweepSize
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::DebugCapsuleSweepSize(float HalfHeight, float Radius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweepSize");
|
|
|
|
UCheatManager_DebugCapsuleSweepSize_Params params;
|
|
params.HalfHeight = HalfHeight;
|
|
params.Radius = Radius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweepPawn
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DebugCapsuleSweepPawn()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweepPawn");
|
|
|
|
UCheatManager_DebugCapsuleSweepPawn_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweepComplex
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::DebugCapsuleSweepComplex(bool bTraceComplex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweepComplex");
|
|
|
|
UCheatManager_DebugCapsuleSweepComplex_Params params;
|
|
params.bTraceComplex = bTraceComplex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweepClear
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DebugCapsuleSweepClear()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweepClear");
|
|
|
|
UCheatManager_DebugCapsuleSweepClear_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweepChannel
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// TEnumAsByte<ECollisionChannel> Channel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::DebugCapsuleSweepChannel(TEnumAsByte<ECollisionChannel> Channel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweepChannel");
|
|
|
|
UCheatManager_DebugCapsuleSweepChannel_Params params;
|
|
params.Channel = Channel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweepCapture
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DebugCapsuleSweepCapture()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweepCapture");
|
|
|
|
UCheatManager_DebugCapsuleSweepCapture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DebugCapsuleSweep
|
|
// (Exec, Native, Public)
|
|
|
|
void UCheatManager::DebugCapsuleSweep()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DebugCapsuleSweep");
|
|
|
|
UCheatManager_DebugCapsuleSweep_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.DamageTarget
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DamageAmount (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::DamageTarget(float DamageAmount)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.DamageTarget");
|
|
|
|
UCheatManager_DamageTarget_Params params;
|
|
params.DamageAmount = DamageAmount;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.CheatScript
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString ScriptName (Parm, ZeroConstructor)
|
|
|
|
void UCheatManager::CheatScript(const struct FString& ScriptName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.CheatScript");
|
|
|
|
UCheatManager_CheatScript_Params params;
|
|
params.ScriptName = ScriptName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.ChangeSize
|
|
// (Exec, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float F (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::ChangeSize(float F)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.ChangeSize");
|
|
|
|
UCheatManager_ChangeSize_Params params;
|
|
params.F = F;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.BugItStringCreator
|
|
// (Exec, Native, Public, HasOutParms, HasDefaults)
|
|
// Parameters:
|
|
// struct FVector ViewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator ViewRotation (Parm, IsPlainOldData)
|
|
// struct FString GoString (Parm, OutParm, ZeroConstructor)
|
|
// struct FString LocString (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UCheatManager::BugItStringCreator(const struct FVector& ViewLocation, const struct FRotator& ViewRotation, struct FString* GoString, struct FString* LocString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.BugItStringCreator");
|
|
|
|
UCheatManager_BugItStringCreator_Params params;
|
|
params.ViewLocation = ViewLocation;
|
|
params.ViewRotation = ViewRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (GoString != nullptr)
|
|
*GoString = params.GoString;
|
|
if (LocString != nullptr)
|
|
*LocString = params.LocString;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.BugItGo
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// float X (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Y (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Z (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Pitch (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Yaw (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Roll (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCheatManager::BugItGo(float X, float Y, float Z, float Pitch, float Yaw, float Roll)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.BugItGo");
|
|
|
|
UCheatManager_BugItGo_Params params;
|
|
params.X = X;
|
|
params.Y = Y;
|
|
params.Z = Z;
|
|
params.Pitch = Pitch;
|
|
params.Yaw = Yaw;
|
|
params.Roll = Roll;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CheatManager.BugIt
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FString ScreenShotDescription (Parm, ZeroConstructor)
|
|
|
|
void UCheatManager::BugIt(const struct FString& ScreenShotDescription)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CheatManager.BugIt");
|
|
|
|
UCheatManager_BugIt_Params params;
|
|
params.ScreenShotDescription = ScreenShotDescription;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.SpawnDefaultController
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void APawn::SpawnDefaultController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.SpawnDefaultController");
|
|
|
|
APawn_SpawnDefaultController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.SetUseViewTranslatedTransform
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewUseViewTranslatedTransform (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::SetUseViewTranslatedTransform(bool bNewUseViewTranslatedTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.SetUseViewTranslatedTransform");
|
|
|
|
APawn_SetUseViewTranslatedTransform_Params params;
|
|
params.bNewUseViewTranslatedTransform = bNewUseViewTranslatedTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.SetCanAffectNavigationGeneration
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bForceUpdate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::SetCanAffectNavigationGeneration(bool bNewValue, bool bForceUpdate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.SetCanAffectNavigationGeneration");
|
|
|
|
APawn_SetCanAffectNavigationGeneration_Params params;
|
|
params.bNewValue = bNewValue;
|
|
params.bForceUpdate = bForceUpdate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.ReceiveUnpossessed
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* OldController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::ReceiveUnpossessed(class AController* OldController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.ReceiveUnpossessed");
|
|
|
|
APawn_ReceiveUnpossessed_Params params;
|
|
params.OldController = OldController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.ReceivePossessed
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class AController* NewController (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::ReceivePossessed(class AController* NewController)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.ReceivePossessed");
|
|
|
|
APawn_ReceivePossessed_Params params;
|
|
params.NewController = NewController;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.PawnMakeNoise
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float Loudness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NoiseLocation (Parm, IsPlainOldData)
|
|
// bool bUseNoiseMakerLocation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* NoiseMaker (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::PawnMakeNoise(float Loudness, const struct FVector& NoiseLocation, bool bUseNoiseMakerLocation, class AActor* NoiseMaker)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.PawnMakeNoise");
|
|
|
|
APawn_PawnMakeNoise_Params params;
|
|
params.Loudness = Loudness;
|
|
params.NoiseLocation = NoiseLocation;
|
|
params.bUseNoiseMakerLocation = bUseNoiseMakerLocation;
|
|
params.NoiseMaker = NoiseMaker;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.OnRep_PlayerState
|
|
// (Native, Public)
|
|
|
|
void APawn::OnRep_PlayerState()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.OnRep_PlayerState");
|
|
|
|
APawn_OnRep_PlayerState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.OnRep_Controller
|
|
// (Native, Public)
|
|
|
|
void APawn::OnRep_Controller()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.OnRep_Controller");
|
|
|
|
APawn_OnRep_Controller_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.LaunchPawn
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector LaunchVelocity (Parm, IsPlainOldData)
|
|
// bool bXYOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bZOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::LaunchPawn(const struct FVector& LaunchVelocity, bool bXYOverride, bool bZOverride)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.LaunchPawn");
|
|
|
|
APawn_LaunchPawn_Params params;
|
|
params.LaunchVelocity = LaunchVelocity;
|
|
params.bXYOverride = bXYOverride;
|
|
params.bZOverride = bZOverride;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.K2_GetMovementInputVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APawn::K2_GetMovementInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.K2_GetMovementInputVector");
|
|
|
|
APawn_K2_GetMovementInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.IsPlayerControlled
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APawn::IsPlayerControlled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.IsPlayerControlled");
|
|
|
|
APawn_IsPlayerControlled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.IsMoveInputIgnored
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APawn::IsMoveInputIgnored()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.IsMoveInputIgnored");
|
|
|
|
APawn_IsMoveInputIgnored_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.IsLocallyControlled
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APawn::IsLocallyControlled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.IsLocallyControlled");
|
|
|
|
APawn_IsLocallyControlled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.IsControlled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APawn::IsControlled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.IsControlled");
|
|
|
|
APawn_IsControlled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetPendingMovementInputVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APawn::GetPendingMovementInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetPendingMovementInputVector");
|
|
|
|
APawn_GetPendingMovementInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetNavAgentLocation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APawn::GetNavAgentLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetNavAgentLocation");
|
|
|
|
APawn_GetNavAgentLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetMovementComponent
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPawnMovementComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPawnMovementComponent* APawn::GetMovementComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetMovementComponent");
|
|
|
|
APawn_GetMovementComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetMovementBaseActor
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class APawn* Pawn (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* APawn::GetMovementBaseActor(class APawn* Pawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetMovementBaseActor");
|
|
|
|
APawn_GetMovementBaseActor_Params params;
|
|
params.Pawn = Pawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetLastMovementInputVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APawn::GetLastMovementInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetLastMovementInputVector");
|
|
|
|
APawn_GetLastMovementInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetControlRotation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator APawn::GetControlRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetControlRotation");
|
|
|
|
APawn_GetControlRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetController
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AController* APawn::GetController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetController");
|
|
|
|
APawn_GetController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.GetBaseAimRotation
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator APawn::GetBaseAimRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.GetBaseAimRotation");
|
|
|
|
APawn_GetBaseAimRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.DetachFromControllerPendingDestroy
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void APawn::DetachFromControllerPendingDestroy()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.DetachFromControllerPendingDestroy");
|
|
|
|
APawn_DetachFromControllerPendingDestroy_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.ConsumeMovementInputVector
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APawn::ConsumeMovementInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.ConsumeMovementInputVector");
|
|
|
|
APawn_ConsumeMovementInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.AddMovementInput
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector WorldDirection (Parm, IsPlainOldData)
|
|
// float ScaleValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bForce (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::AddMovementInput(const struct FVector& WorldDirection, float ScaleValue, bool bForce)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.AddMovementInput");
|
|
|
|
APawn_AddMovementInput_Params params;
|
|
params.WorldDirection = WorldDirection;
|
|
params.ScaleValue = ScaleValue;
|
|
params.bForce = bForce;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.AddControllerYawInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::AddControllerYawInput(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.AddControllerYawInput");
|
|
|
|
APawn_AddControllerYawInput_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.AddControllerRollInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::AddControllerRollInput(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.AddControllerRollInput");
|
|
|
|
APawn_AddControllerRollInput_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Pawn.AddControllerPitchInput
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APawn::AddControllerPitchInput(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Pawn.AddControllerPitchInput");
|
|
|
|
APawn_AddControllerPitchInput_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.UnCrouch
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bClientSimulation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::UnCrouch(bool bClientSimulation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.UnCrouch");
|
|
|
|
ACharacter_UnCrouch_Params params;
|
|
params.bClientSimulation = bClientSimulation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.StopJumping
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void ACharacter::StopJumping()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.StopJumping");
|
|
|
|
ACharacter_StopJumping_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.StopAnimMontage
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* AnimMontage (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::StopAnimMontage(class UAnimMontage* AnimMontage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.StopAnimMontage");
|
|
|
|
ACharacter_StopAnimMontage_Params params;
|
|
params.AnimMontage = AnimMontage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.SetReplicateMovement
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInReplicateMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::SetReplicateMovement(bool bInReplicateMovement)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.SetReplicateMovement");
|
|
|
|
ACharacter_SetReplicateMovement_Params params;
|
|
params.bInReplicateMovement = bInReplicateMovement;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.RootMotionDebugClientPrintOnScreen
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
|
|
void ACharacter::RootMotionDebugClientPrintOnScreen(const struct FString& inString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.RootMotionDebugClientPrintOnScreen");
|
|
|
|
ACharacter_RootMotionDebugClientPrintOnScreen_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.PlayAnimMontage
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* AnimMontage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName StartSectionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float ACharacter::PlayAnimMontage(class UAnimMontage* AnimMontage, float InPlayRate, const struct FName& StartSectionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.PlayAnimMontage");
|
|
|
|
ACharacter_PlayAnimMontage_Params params;
|
|
params.AnimMontage = AnimMontage;
|
|
params.InPlayRate = InPlayRate;
|
|
params.StartSectionName = StartSectionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnWalkingOffLedge
|
|
// (Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FVector PreviousFloorImpactNormal (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector PreviousFloorContactNormal (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector PreviousLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float TimeDelta (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::OnWalkingOffLedge(const struct FVector& PreviousFloorImpactNormal, const struct FVector& PreviousFloorContactNormal, const struct FVector& PreviousLocation, float TimeDelta)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnWalkingOffLedge");
|
|
|
|
ACharacter_OnWalkingOffLedge_Params params;
|
|
params.PreviousFloorImpactNormal = PreviousFloorImpactNormal;
|
|
params.PreviousFloorContactNormal = PreviousFloorContactNormal;
|
|
params.PreviousLocation = PreviousLocation;
|
|
params.TimeDelta = TimeDelta;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnRep_RootMotion
|
|
// (Final, Native, Public)
|
|
|
|
void ACharacter::OnRep_RootMotion()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnRep_RootMotion");
|
|
|
|
ACharacter_OnRep_RootMotion_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnRep_ReplicatedBasedMovement
|
|
// (Native, Public)
|
|
|
|
void ACharacter::OnRep_ReplicatedBasedMovement()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnRep_ReplicatedBasedMovement");
|
|
|
|
ACharacter_OnRep_ReplicatedBasedMovement_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnRep_IsCrouched
|
|
// (Native, Public)
|
|
|
|
void ACharacter::OnRep_IsCrouched()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnRep_IsCrouched");
|
|
|
|
ACharacter_OnRep_IsCrouched_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnLaunched
|
|
// (Event, Public, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FVector LaunchVelocity (Parm, IsPlainOldData)
|
|
// bool bXYOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bZOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::OnLaunched(const struct FVector& LaunchVelocity, bool bXYOverride, bool bZOverride)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnLaunched");
|
|
|
|
ACharacter_OnLaunched_Params params;
|
|
params.LaunchVelocity = LaunchVelocity;
|
|
params.bXYOverride = bXYOverride;
|
|
params.bZOverride = bZOverride;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnLanded
|
|
// (Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void ACharacter::OnLanded(const struct FHitResult& Hit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnLanded");
|
|
|
|
ACharacter_OnLanded_Params params;
|
|
params.Hit = Hit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.OnJumped
|
|
// (Native, Event, Public, BlueprintEvent)
|
|
|
|
void ACharacter::OnJumped()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.OnJumped");
|
|
|
|
ACharacter_OnJumped_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.LaunchCharacter
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector LaunchVelocity (Parm, IsPlainOldData)
|
|
// bool bXYOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bZOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::LaunchCharacter(const struct FVector& LaunchVelocity, bool bXYOverride, bool bZOverride)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.LaunchCharacter");
|
|
|
|
ACharacter_LaunchCharacter_Params params;
|
|
params.LaunchVelocity = LaunchVelocity;
|
|
params.bXYOverride = bXYOverride;
|
|
params.bZOverride = bZOverride;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.K2_UpdateCustomMovement
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::K2_UpdateCustomMovement(float DeltaTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.K2_UpdateCustomMovement");
|
|
|
|
ACharacter_K2_UpdateCustomMovement_Params params;
|
|
params.DeltaTime = DeltaTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.K2_OnStartCrouch
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float HalfHeightAdjust (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScaledHalfHeightAdjust (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::K2_OnStartCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.K2_OnStartCrouch");
|
|
|
|
ACharacter_K2_OnStartCrouch_Params params;
|
|
params.HalfHeightAdjust = HalfHeightAdjust;
|
|
params.ScaledHalfHeightAdjust = ScaledHalfHeightAdjust;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.K2_OnMovementModeChanged
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<EMovementMode> PrevMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EMovementMode> NewMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char PrevCustomMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char NewCustomMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::K2_OnMovementModeChanged(TEnumAsByte<EMovementMode> PrevMovementMode, TEnumAsByte<EMovementMode> NewMovementMode, unsigned char PrevCustomMode, unsigned char NewCustomMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.K2_OnMovementModeChanged");
|
|
|
|
ACharacter_K2_OnMovementModeChanged_Params params;
|
|
params.PrevMovementMode = PrevMovementMode;
|
|
params.NewMovementMode = NewMovementMode;
|
|
params.PrevCustomMode = PrevCustomMode;
|
|
params.NewCustomMode = NewCustomMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.K2_OnEndCrouch
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float HalfHeightAdjust (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScaledHalfHeightAdjust (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::K2_OnEndCrouch(float HalfHeightAdjust, float ScaledHalfHeightAdjust)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.K2_OnEndCrouch");
|
|
|
|
ACharacter_K2_OnEndCrouch_Params params;
|
|
params.HalfHeightAdjust = HalfHeightAdjust;
|
|
params.ScaledHalfHeightAdjust = ScaledHalfHeightAdjust;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.Jump
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void ACharacter::Jump()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.Jump");
|
|
|
|
ACharacter_Jump_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.IsPlayingRootMotion
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ACharacter::IsPlayingRootMotion()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.IsPlayingRootMotion");
|
|
|
|
ACharacter_IsPlayingRootMotion_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.IsPlayingNetworkedRootMotionMontage
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ACharacter::IsPlayingNetworkedRootMotionMontage()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.IsPlayingNetworkedRootMotionMontage");
|
|
|
|
ACharacter_IsPlayingNetworkedRootMotionMontage_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.IsPlayer
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ACharacter::IsPlayer()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.IsPlayer");
|
|
|
|
ACharacter_IsPlayer_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.IsJumpProvidingForce
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ACharacter::IsJumpProvidingForce()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.IsJumpProvidingForce");
|
|
|
|
ACharacter_IsJumpProvidingForce_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.GetCurrentMontage
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAnimMontage* ACharacter::GetCurrentMontage()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.GetCurrentMontage");
|
|
|
|
ACharacter_GetCurrentMontage_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.GetBaseTranslationOffset
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector ACharacter::GetBaseTranslationOffset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.GetBaseTranslationOffset");
|
|
|
|
ACharacter_GetBaseTranslationOffset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.GetBaseRotationOffsetRotator
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator ACharacter::GetBaseRotationOffsetRotator()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.GetBaseRotationOffsetRotator");
|
|
|
|
ACharacter_GetBaseRotationOffsetRotator_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.GetAnimRootMotionTranslationScale
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float ACharacter::GetAnimRootMotionTranslationScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.GetAnimRootMotionTranslationScale");
|
|
|
|
ACharacter_GetAnimRootMotionTranslationScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.Crouch
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bClientSimulation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ACharacter::Crouch(bool bClientSimulation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.Crouch");
|
|
|
|
ACharacter_Crouch_Params params;
|
|
params.bClientSimulation = bClientSimulation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.ClientCheatWalk
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void ACharacter::ClientCheatWalk()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.ClientCheatWalk");
|
|
|
|
ACharacter_ClientCheatWalk_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.ClientCheatGhost
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void ACharacter::ClientCheatGhost()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.ClientCheatGhost");
|
|
|
|
ACharacter_ClientCheatGhost_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.ClientCheatFly
|
|
// (Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void ACharacter::ClientCheatFly()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.ClientCheatFly");
|
|
|
|
ACharacter_ClientCheatFly_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.CanJumpInternal
|
|
// (Native, Event, Protected, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ACharacter::CanJumpInternal()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.CanJumpInternal");
|
|
|
|
ACharacter_CanJumpInternal_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.CanJump
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ACharacter::CanJump()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.CanJump");
|
|
|
|
ACharacter_CanJump_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Character.CacheInitialMeshOffset
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector MeshRelativeLocation (Parm, IsPlainOldData)
|
|
// struct FRotator MeshRelativeRotation (Parm, IsPlainOldData)
|
|
|
|
void ACharacter::CacheInitialMeshOffset(const struct FVector& MeshRelativeLocation, const struct FRotator& MeshRelativeRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Character.CacheInitialMeshOffset");
|
|
|
|
ACharacter_CacheInitialMeshOffset_Params params;
|
|
params.MeshRelativeLocation = MeshRelativeLocation;
|
|
params.MeshRelativeRotation = MeshRelativeRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.SetVectorParameterValueOnMaterials
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ParameterValue (ConstParm, Parm, IsPlainOldData)
|
|
|
|
void UMeshComponent::SetVectorParameterValueOnMaterials(const struct FName& ParameterName, const struct FVector& ParameterValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.SetVectorParameterValueOnMaterials");
|
|
|
|
UMeshComponent_SetVectorParameterValueOnMaterials_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.ParameterValue = ParameterValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.SetScalarParameterValueOnMaterials
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ParameterValue (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMeshComponent::SetScalarParameterValueOnMaterials(const struct FName& ParameterName, float ParameterValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.SetScalarParameterValueOnMaterials");
|
|
|
|
UMeshComponent_SetScalarParameterValueOnMaterials_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.ParameterValue = ParameterValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.PrestreamTextures
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Seconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPrioritizeCharacterTextures (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int CinematicTextureGroups (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMeshComponent::PrestreamTextures(float Seconds, bool bPrioritizeCharacterTextures, int CinematicTextureGroups)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.PrestreamTextures");
|
|
|
|
UMeshComponent_PrestreamTextures_Params params;
|
|
params.Seconds = Seconds;
|
|
params.bPrioritizeCharacterTextures = bPrioritizeCharacterTextures;
|
|
params.CinematicTextureGroups = CinematicTextureGroups;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.IsMaterialSlotNameValid
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName MaterialSlotName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UMeshComponent::IsMaterialSlotNameValid(const struct FName& MaterialSlotName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.IsMaterialSlotNameValid");
|
|
|
|
UMeshComponent_IsMaterialSlotNameValid_Params params;
|
|
params.MaterialSlotName = MaterialSlotName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.GetMaterialSlotNames
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FName> UMeshComponent::GetMaterialSlotNames()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.GetMaterialSlotNames");
|
|
|
|
UMeshComponent_GetMaterialSlotNames_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.GetMaterials
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class UMaterialInterface*> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<class UMaterialInterface*> UMeshComponent::GetMaterials()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.GetMaterials");
|
|
|
|
UMeshComponent_GetMaterials_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshComponent.GetMaterialIndex
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName MaterialSlotName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UMeshComponent::GetMaterialIndex(const struct FName& MaterialSlotName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshComponent.GetMaterialIndex");
|
|
|
|
UMeshComponent_GetMaterialIndex_Params params;
|
|
params.MaterialSlotName = MaterialSlotName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMeshComponent.SetStaticMesh
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UStaticMesh* NewMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UStaticMeshComponent::SetStaticMesh(class UStaticMesh* NewMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMeshComponent.SetStaticMesh");
|
|
|
|
UStaticMeshComponent_SetStaticMesh_Params params;
|
|
params.NewMesh = NewMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMeshComponent.SetForcedLodModel
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewForcedLodModel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStaticMeshComponent::SetForcedLodModel(int NewForcedLodModel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMeshComponent.SetForcedLodModel");
|
|
|
|
UStaticMeshComponent_SetForcedLodModel_Params params;
|
|
params.NewForcedLodModel = NewForcedLodModel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMeshComponent.SetDistanceFieldSelfShadowBias
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStaticMeshComponent::SetDistanceFieldSelfShadowBias(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMeshComponent.SetDistanceFieldSelfShadowBias");
|
|
|
|
UStaticMeshComponent_SetDistanceFieldSelfShadowBias_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMeshComponent.SetDirty
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UStaticMeshComponent::SetDirty()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMeshComponent.SetDirty");
|
|
|
|
UStaticMeshComponent_SetDirty_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMeshComponent.OnRep_StaticMesh
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class UStaticMesh* OldStaticMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStaticMeshComponent::OnRep_StaticMesh(class UStaticMesh* OldStaticMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMeshComponent.OnRep_StaticMesh");
|
|
|
|
UStaticMeshComponent_OnRep_StaticMesh_Params params;
|
|
params.OldStaticMesh = OldStaticMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMeshComponent.GetLocalBounds
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Min (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Max (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UStaticMeshComponent::GetLocalBounds(struct FVector* Min, struct FVector* Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMeshComponent.GetLocalBounds");
|
|
|
|
UStaticMeshComponent_GetLocalBounds_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Min != nullptr)
|
|
*Min = params.Min;
|
|
if (Max != nullptr)
|
|
*Max = params.Max;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetUseFieldOfViewForLOD
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInUseFieldOfViewForLOD (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetUseFieldOfViewForLOD(bool bInUseFieldOfViewForLOD)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetUseFieldOfViewForLOD");
|
|
|
|
UCameraComponent_SetUseFieldOfViewForLOD_Params params;
|
|
params.bInUseFieldOfViewForLOD = bInUseFieldOfViewForLOD;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetProjectionMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ECameraProjectionMode> InProjectionMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetProjectionMode(TEnumAsByte<ECameraProjectionMode> InProjectionMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetProjectionMode");
|
|
|
|
UCameraComponent_SetProjectionMode_Params params;
|
|
params.InProjectionMode = InProjectionMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetPostProcessBlendWeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPostProcessBlendWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetPostProcessBlendWeight(float InPostProcessBlendWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetPostProcessBlendWeight");
|
|
|
|
UCameraComponent_SetPostProcessBlendWeight_Params params;
|
|
params.InPostProcessBlendWeight = InPostProcessBlendWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetOrthoWidth
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOrthoWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetOrthoWidth(float InOrthoWidth)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetOrthoWidth");
|
|
|
|
UCameraComponent_SetOrthoWidth_Params params;
|
|
params.InOrthoWidth = InOrthoWidth;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetOrthoNearClipPlane
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOrthoNearClipPlane (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetOrthoNearClipPlane(float InOrthoNearClipPlane)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetOrthoNearClipPlane");
|
|
|
|
UCameraComponent_SetOrthoNearClipPlane_Params params;
|
|
params.InOrthoNearClipPlane = InOrthoNearClipPlane;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetOrthoFarClipPlane
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOrthoFarClipPlane (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetOrthoFarClipPlane(float InOrthoFarClipPlane)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetOrthoFarClipPlane");
|
|
|
|
UCameraComponent_SetOrthoFarClipPlane_Params params;
|
|
params.InOrthoFarClipPlane = InOrthoFarClipPlane;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetFieldOfView
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFieldOfView (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetFieldOfView(float InFieldOfView)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetFieldOfView");
|
|
|
|
UCameraComponent_SetFieldOfView_Params params;
|
|
params.InFieldOfView = InFieldOfView;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetConstraintAspectRatio
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInConstrainAspectRatio (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetConstraintAspectRatio(bool bInConstrainAspectRatio)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetConstraintAspectRatio");
|
|
|
|
UCameraComponent_SetConstraintAspectRatio_Params params;
|
|
params.bInConstrainAspectRatio = bInConstrainAspectRatio;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetAspectRatio
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InAspectRatio (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetAspectRatio(float InAspectRatio)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetAspectRatio");
|
|
|
|
UCameraComponent_SetAspectRatio_Params params;
|
|
params.InAspectRatio = InAspectRatio;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.SetActive
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewActive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bReset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::SetActive(bool bNewActive, bool bReset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.SetActive");
|
|
|
|
UCameraComponent_SetActive_Params params;
|
|
params.bNewActive = bNewActive;
|
|
params.bReset = bReset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.RemoveBlendable
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TScriptInterface<class UBlendableInterface> InBlendableObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::RemoveBlendable(const TScriptInterface<class UBlendableInterface>& InBlendableObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.RemoveBlendable");
|
|
|
|
UCameraComponent_RemoveBlendable_Params params;
|
|
params.InBlendableObject = InBlendableObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.GetCameraView
|
|
// (Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FMinimalViewInfo DesiredView (Parm, OutParm)
|
|
|
|
void UCameraComponent::GetCameraView(float DeltaTime, struct FMinimalViewInfo* DesiredView)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.GetCameraView");
|
|
|
|
UCameraComponent_GetCameraView_Params params;
|
|
params.DeltaTime = DeltaTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (DesiredView != nullptr)
|
|
*DesiredView = params.DesiredView;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.ApplyDrawDistanceOffset
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFieldOfView (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::ApplyDrawDistanceOffset(float InFieldOfView)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.ApplyDrawDistanceOffset");
|
|
|
|
UCameraComponent_ApplyDrawDistanceOffset_Params params;
|
|
params.InFieldOfView = InFieldOfView;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraComponent.AddOrUpdateBlendable
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TScriptInterface<class UBlendableInterface> InBlendableObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraComponent::AddOrUpdateBlendable(const TScriptInterface<class UBlendableInterface>& InBlendableObject, float InWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraComponent.AddOrUpdateBlendable");
|
|
|
|
UCameraComponent_AddOrUpdateBlendable_Params params;
|
|
params.InBlendableObject = InBlendableObject;
|
|
params.InWeight = InWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ShowHUD
|
|
// (Exec, Native, Public)
|
|
|
|
void AHUD::ShowHUD()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ShowHUD");
|
|
|
|
AHUD_ShowHUD_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ShowDebugToggleSubCategory
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName Category (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ShowDebugToggleSubCategory(const struct FName& Category)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ShowDebugToggleSubCategory");
|
|
|
|
AHUD_ShowDebugToggleSubCategory_Params params;
|
|
params.Category = Category;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ShowDebugForReticleTargetToggle
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// class UClass* DesiredClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ShowDebugForReticleTargetToggle(class UClass* DesiredClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ShowDebugForReticleTargetToggle");
|
|
|
|
AHUD_ShowDebugForReticleTargetToggle_Params params;
|
|
params.DesiredClass = DesiredClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ShowDebug
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName DebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ShowDebug(const struct FName& DebugType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ShowDebug");
|
|
|
|
AHUD_ShowDebug_Params params;
|
|
params.DebugType = DebugType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.RemoveDebugText
|
|
// (Final, Net, NetReliable, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// class AActor* SrcActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLeaveDurationText (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::RemoveDebugText(class AActor* SrcActor, bool bLeaveDurationText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.RemoveDebugText");
|
|
|
|
AHUD_RemoveDebugText_Params params;
|
|
params.SrcActor = SrcActor;
|
|
params.bLeaveDurationText = bLeaveDurationText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.RemoveAllDebugStrings
|
|
// (Final, Net, NetReliable, Native, Event, Public, NetClient)
|
|
|
|
void AHUD::RemoveAllDebugStrings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.RemoveAllDebugStrings");
|
|
|
|
AHUD_RemoveAllDebugStrings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ReceiveHitBoxRelease
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FName BoxName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ReceiveHitBoxRelease(const struct FName& BoxName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ReceiveHitBoxRelease");
|
|
|
|
AHUD_ReceiveHitBoxRelease_Params params;
|
|
params.BoxName = BoxName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ReceiveHitBoxEndCursorOver
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FName BoxName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ReceiveHitBoxEndCursorOver(const struct FName& BoxName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ReceiveHitBoxEndCursorOver");
|
|
|
|
AHUD_ReceiveHitBoxEndCursorOver_Params params;
|
|
params.BoxName = BoxName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ReceiveHitBoxClick
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FName BoxName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ReceiveHitBoxClick(const struct FName& BoxName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ReceiveHitBoxClick");
|
|
|
|
AHUD_ReceiveHitBoxClick_Params params;
|
|
params.BoxName = BoxName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ReceiveHitBoxBeginCursorOver
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FName BoxName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ReceiveHitBoxBeginCursorOver(const struct FName& BoxName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ReceiveHitBoxBeginCursorOver");
|
|
|
|
AHUD_ReceiveHitBoxBeginCursorOver_Params params;
|
|
params.BoxName = BoxName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.ReceiveDrawHUD
|
|
// (BlueprintCosmetic, Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// int SizeX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SizeY (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::ReceiveDrawHUD(int SizeX, int SizeY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.ReceiveDrawHUD");
|
|
|
|
AHUD_ReceiveDrawHUD_Params params;
|
|
params.SizeX = SizeX;
|
|
params.SizeY = SizeY;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.Project
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector AHUD::Project(const struct FVector& Location)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.Project");
|
|
|
|
AHUD_Project_Params params;
|
|
params.Location = Location;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.GetTextSize
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FString Text (Parm, ZeroConstructor)
|
|
// float OutWidth (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutHeight (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class UFont* Font (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::GetTextSize(const struct FString& Text, class UFont* Font, float Scale, float* OutWidth, float* OutHeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.GetTextSize");
|
|
|
|
AHUD_GetTextSize_Params params;
|
|
params.Text = Text;
|
|
params.Font = Font;
|
|
params.Scale = Scale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutWidth != nullptr)
|
|
*OutWidth = params.OutWidth;
|
|
if (OutHeight != nullptr)
|
|
*OutHeight = params.OutHeight;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.GetOwningPlayerController
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* AHUD::GetOwningPlayerController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.GetOwningPlayerController");
|
|
|
|
AHUD_GetOwningPlayerController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.GetOwningPawn
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* AHUD::GetOwningPawn()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.GetOwningPawn");
|
|
|
|
AHUD_GetOwningPawn_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.GetActorsInSelectionRectangle
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* ClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D FirstPoint (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D SecondPoint (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
// bool bIncludeNonCollidingComponents (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bActorMustBeFullyEnclosed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::GetActorsInSelectionRectangle(class UClass* ClassFilter, const struct FVector2D& FirstPoint, const struct FVector2D& SecondPoint, bool bIncludeNonCollidingComponents, bool bActorMustBeFullyEnclosed, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.GetActorsInSelectionRectangle");
|
|
|
|
AHUD_GetActorsInSelectionRectangle_Params params;
|
|
params.ClassFilter = ClassFilter;
|
|
params.FirstPoint = FirstPoint;
|
|
params.SecondPoint = SecondPoint;
|
|
params.bIncludeNonCollidingComponents = bIncludeNonCollidingComponents;
|
|
params.bActorMustBeFullyEnclosed = bActorMustBeFullyEnclosed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawTextureSimple
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bScalePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::DrawTextureSimple(class UTexture* Texture, float ScreenX, float ScreenY, float Scale, bool bScalePosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawTextureSimple");
|
|
|
|
AHUD_DrawTextureSimple_Params params;
|
|
params.Texture = Texture;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
params.Scale = Scale;
|
|
params.bScalePosition = bScalePosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawTexture
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenW (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenH (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TextureU (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TextureV (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TextureUWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TextureVHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TintColor (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EBlendMode> BlendMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bScalePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Rotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D RotPivot (Parm, IsPlainOldData)
|
|
|
|
void AHUD::DrawTexture(class UTexture* Texture, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float TextureU, float TextureV, float TextureUWidth, float TextureVHeight, const struct FLinearColor& TintColor, TEnumAsByte<EBlendMode> BlendMode, float Scale, bool bScalePosition, float Rotation, const struct FVector2D& RotPivot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawTexture");
|
|
|
|
AHUD_DrawTexture_Params params;
|
|
params.Texture = Texture;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
params.ScreenW = ScreenW;
|
|
params.ScreenH = ScreenH;
|
|
params.TextureU = TextureU;
|
|
params.TextureV = TextureV;
|
|
params.TextureUWidth = TextureUWidth;
|
|
params.TextureVHeight = TextureVHeight;
|
|
params.TintColor = TintColor;
|
|
params.BlendMode = BlendMode;
|
|
params.Scale = Scale;
|
|
params.bScalePosition = bScalePosition;
|
|
params.Rotation = Rotation;
|
|
params.RotPivot = RotPivot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawText
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Text (Parm, ZeroConstructor)
|
|
// struct FLinearColor TextColor (Parm, IsPlainOldData)
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UFont* Font (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bScalePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::DrawText(const struct FString& Text, const struct FLinearColor& TextColor, float ScreenX, float ScreenY, class UFont* Font, float Scale, bool bScalePosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawText");
|
|
|
|
AHUD_DrawText_Params params;
|
|
params.Text = Text;
|
|
params.TextColor = TextColor;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
params.Font = Font;
|
|
params.Scale = Scale;
|
|
params.bScalePosition = bScalePosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawRect
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor RectColor (Parm, IsPlainOldData)
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenW (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenH (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::DrawRect(const struct FLinearColor& RectColor, float ScreenX, float ScreenY, float ScreenW, float ScreenH)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawRect");
|
|
|
|
AHUD_DrawRect_Params params;
|
|
params.RectColor = RectColor;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
params.ScreenW = ScreenW;
|
|
params.ScreenH = ScreenH;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawMaterialTriangle
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D V0_Pos (Parm, IsPlainOldData)
|
|
// struct FVector2D V1_Pos (Parm, IsPlainOldData)
|
|
// struct FVector2D V2_Pos (Parm, IsPlainOldData)
|
|
// struct FVector2D V0_UV (Parm, IsPlainOldData)
|
|
// struct FVector2D V1_UV (Parm, IsPlainOldData)
|
|
// struct FVector2D V2_UV (Parm, IsPlainOldData)
|
|
// struct FLinearColor V0_Color (Parm, IsPlainOldData)
|
|
// struct FLinearColor V1_Color (Parm, IsPlainOldData)
|
|
// struct FLinearColor V2_Color (Parm, IsPlainOldData)
|
|
|
|
void AHUD::DrawMaterialTriangle(class UMaterialInterface* Material, const struct FVector2D& V0_Pos, const struct FVector2D& V1_Pos, const struct FVector2D& V2_Pos, const struct FVector2D& V0_UV, const struct FVector2D& V1_UV, const struct FVector2D& V2_UV, const struct FLinearColor& V0_Color, const struct FLinearColor& V1_Color, const struct FLinearColor& V2_Color)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawMaterialTriangle");
|
|
|
|
AHUD_DrawMaterialTriangle_Params params;
|
|
params.Material = Material;
|
|
params.V0_Pos = V0_Pos;
|
|
params.V1_Pos = V1_Pos;
|
|
params.V2_Pos = V2_Pos;
|
|
params.V0_UV = V0_UV;
|
|
params.V1_UV = V1_UV;
|
|
params.V2_UV = V2_UV;
|
|
params.V0_Color = V0_Color;
|
|
params.V1_Color = V1_Color;
|
|
params.V2_Color = V2_Color;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawMaterialSimple
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenW (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenH (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bScalePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::DrawMaterialSimple(class UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float Scale, bool bScalePosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawMaterialSimple");
|
|
|
|
AHUD_DrawMaterialSimple_Params params;
|
|
params.Material = Material;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
params.ScreenW = ScreenW;
|
|
params.ScreenH = ScreenH;
|
|
params.Scale = Scale;
|
|
params.bScalePosition = bScalePosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawMaterial
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenW (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenH (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaterialU (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaterialV (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaterialUWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaterialVHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bScalePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Rotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D RotPivot (Parm, IsPlainOldData)
|
|
|
|
void AHUD::DrawMaterial(class UMaterialInterface* Material, float ScreenX, float ScreenY, float ScreenW, float ScreenH, float MaterialU, float MaterialV, float MaterialUWidth, float MaterialVHeight, float Scale, bool bScalePosition, float Rotation, const struct FVector2D& RotPivot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawMaterial");
|
|
|
|
AHUD_DrawMaterial_Params params;
|
|
params.Material = Material;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
params.ScreenW = ScreenW;
|
|
params.ScreenH = ScreenH;
|
|
params.MaterialU = MaterialU;
|
|
params.MaterialV = MaterialV;
|
|
params.MaterialUWidth = MaterialUWidth;
|
|
params.MaterialVHeight = MaterialVHeight;
|
|
params.Scale = Scale;
|
|
params.bScalePosition = bScalePosition;
|
|
params.Rotation = Rotation;
|
|
params.RotPivot = RotPivot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.DrawLine
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float StartScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float EndScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float EndScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float LineThickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::DrawLine(float StartScreenX, float StartScreenY, float EndScreenX, float EndScreenY, const struct FLinearColor& LineColor, float LineThickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.DrawLine");
|
|
|
|
AHUD_DrawLine_Params params;
|
|
params.StartScreenX = StartScreenX;
|
|
params.StartScreenY = StartScreenY;
|
|
params.EndScreenX = EndScreenX;
|
|
params.EndScreenY = EndScreenY;
|
|
params.LineColor = LineColor;
|
|
params.LineThickness = LineThickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.Deproject
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ScreenX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ScreenY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector WorldPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector WorldDirection (Parm, OutParm, IsPlainOldData)
|
|
|
|
void AHUD::Deproject(float ScreenX, float ScreenY, struct FVector* WorldPosition, struct FVector* WorldDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.Deproject");
|
|
|
|
AHUD_Deproject_Params params;
|
|
params.ScreenX = ScreenX;
|
|
params.ScreenY = ScreenY;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (WorldPosition != nullptr)
|
|
*WorldPosition = params.WorldPosition;
|
|
if (WorldDirection != nullptr)
|
|
*WorldDirection = params.WorldDirection;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.AddHitBox
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D Position (Parm, IsPlainOldData)
|
|
// struct FVector2D Size (Parm, IsPlainOldData)
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bConsumesInput (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Priority (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::AddHitBox(const struct FVector2D& Position, const struct FVector2D& Size, const struct FName& InName, bool bConsumesInput, int Priority)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.AddHitBox");
|
|
|
|
AHUD_AddHitBox_Params params;
|
|
params.Position = Position;
|
|
params.Size = Size;
|
|
params.InName = InName;
|
|
params.bConsumesInput = bConsumesInput;
|
|
params.Priority = Priority;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.HUD.AddDebugText
|
|
// (Final, Net, NetReliable, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// struct FString DebugText (Parm, ZeroConstructor)
|
|
// class AActor* SrcActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Offset (Parm, IsPlainOldData)
|
|
// struct FVector DesiredOffset (Parm, IsPlainOldData)
|
|
// struct FColor TextColor (Parm, IsPlainOldData)
|
|
// bool bSkipOverwriteCheck (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAbsoluteLocation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bKeepAttachedToActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UFont* InFont (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FontScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDrawShadow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AHUD::AddDebugText(const struct FString& DebugText, class AActor* SrcActor, float Duration, const struct FVector& Offset, const struct FVector& DesiredOffset, const struct FColor& TextColor, bool bSkipOverwriteCheck, bool bAbsoluteLocation, bool bKeepAttachedToActor, class UFont* InFont, float FontScale, bool bDrawShadow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HUD.AddDebugText");
|
|
|
|
AHUD_AddDebugText_Params params;
|
|
params.DebugText = DebugText;
|
|
params.SrcActor = SrcActor;
|
|
params.Duration = Duration;
|
|
params.Offset = Offset;
|
|
params.DesiredOffset = DesiredOffset;
|
|
params.TextColor = TextColor;
|
|
params.bSkipOverwriteCheck = bSkipOverwriteCheck;
|
|
params.bAbsoluteLocation = bAbsoluteLocation;
|
|
params.bKeepAttachedToActor = bKeepAttachedToActor;
|
|
params.InFont = InFont;
|
|
params.FontScale = FontScale;
|
|
params.bDrawShadow = bDrawShadow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.StopMovementKeepPathing
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UNavMovementComponent::StopMovementKeepPathing()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.StopMovementKeepPathing");
|
|
|
|
UNavMovementComponent_StopMovementKeepPathing_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.StopActiveMovement
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UNavMovementComponent::StopActiveMovement()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.StopActiveMovement");
|
|
|
|
UNavMovementComponent_StopActiveMovement_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.IsSwimming
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavMovementComponent::IsSwimming()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.IsSwimming");
|
|
|
|
UNavMovementComponent_IsSwimming_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.IsMovingOnGround
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavMovementComponent::IsMovingOnGround()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.IsMovingOnGround");
|
|
|
|
UNavMovementComponent_IsMovingOnGround_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.IsFlying
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavMovementComponent::IsFlying()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.IsFlying");
|
|
|
|
UNavMovementComponent_IsFlying_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.IsFalling
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavMovementComponent::IsFalling()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.IsFalling");
|
|
|
|
UNavMovementComponent_IsFalling_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavMovementComponent.IsCrouching
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavMovementComponent::IsCrouching()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavMovementComponent.IsCrouching");
|
|
|
|
UNavMovementComponent_IsCrouching_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.K2_GetInputVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPawnMovementComponent::K2_GetInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.K2_GetInputVector");
|
|
|
|
UPawnMovementComponent_K2_GetInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.IsMoveInputIgnored
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPawnMovementComponent::IsMoveInputIgnored()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.IsMoveInputIgnored");
|
|
|
|
UPawnMovementComponent_IsMoveInputIgnored_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.GetPendingInputVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPawnMovementComponent::GetPendingInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.GetPendingInputVector");
|
|
|
|
UPawnMovementComponent_GetPendingInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.GetPawnOwner
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* UPawnMovementComponent::GetPawnOwner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.GetPawnOwner");
|
|
|
|
UPawnMovementComponent_GetPawnOwner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.GetLastInputVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPawnMovementComponent::GetLastInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.GetLastInputVector");
|
|
|
|
UPawnMovementComponent_GetLastInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.ConsumeInputVector
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPawnMovementComponent::ConsumeInputVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.ConsumeInputVector");
|
|
|
|
UPawnMovementComponent_ConsumeInputVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnMovementComponent.AddInputVector
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector WorldVector (Parm, IsPlainOldData)
|
|
// bool bForce (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPawnMovementComponent::AddInputVector(const struct FVector& WorldVector, bool bForce)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnMovementComponent.AddInputVector");
|
|
|
|
UPawnMovementComponent_AddInputVector_Params params;
|
|
params.WorldVector = WorldVector;
|
|
params.bForce = bForce;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetWalkableFloorZ
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InWalkableFloorZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetWalkableFloorZ(float InWalkableFloorZ)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetWalkableFloorZ");
|
|
|
|
UCharacterMovementComponent_SetWalkableFloorZ_Params params;
|
|
params.InWalkableFloorZ = InWalkableFloorZ;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetWalkableFloorAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InWalkableFloorAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetWalkableFloorAngle(float InWalkableFloorAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetWalkableFloorAngle");
|
|
|
|
UCharacterMovementComponent_SetWalkableFloorAngle_Params params;
|
|
params.InWalkableFloorAngle = InWalkableFloorAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetMovementMode
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EMovementMode> NewMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char NewCustomMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetMovementMode(TEnumAsByte<EMovementMode> NewMovementMode, unsigned char NewCustomMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetMovementMode");
|
|
|
|
UCharacterMovementComponent_SetMovementMode_Params params;
|
|
params.NewMovementMode = NewMovementMode;
|
|
params.NewCustomMode = NewCustomMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetGroupsToIgnoreMask
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FNavAvoidanceMask GroupMask (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetGroupsToIgnoreMask(const struct FNavAvoidanceMask& GroupMask)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetGroupsToIgnoreMask");
|
|
|
|
UCharacterMovementComponent_SetGroupsToIgnoreMask_Params params;
|
|
params.GroupMask = GroupMask;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetGroupsToIgnore
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int GroupFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetGroupsToIgnore(int GroupFlags)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetGroupsToIgnore");
|
|
|
|
UCharacterMovementComponent_SetGroupsToIgnore_Params params;
|
|
params.GroupFlags = GroupFlags;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetGroupsToAvoidMask
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FNavAvoidanceMask GroupMask (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetGroupsToAvoidMask(const struct FNavAvoidanceMask& GroupMask)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetGroupsToAvoidMask");
|
|
|
|
UCharacterMovementComponent_SetGroupsToAvoidMask_Params params;
|
|
params.GroupMask = GroupMask;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetGroupsToAvoid
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int GroupFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetGroupsToAvoid(int GroupFlags)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetGroupsToAvoid");
|
|
|
|
UCharacterMovementComponent_SetGroupsToAvoid_Params params;
|
|
params.GroupFlags = GroupFlags;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetAvoidanceGroupMask
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FNavAvoidanceMask GroupMask (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetAvoidanceGroupMask(const struct FNavAvoidanceMask& GroupMask)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetAvoidanceGroupMask");
|
|
|
|
UCharacterMovementComponent_SetAvoidanceGroupMask_Params params;
|
|
params.GroupMask = GroupMask;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetAvoidanceGroup
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int GroupFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetAvoidanceGroup(int GroupFlags)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetAvoidanceGroup");
|
|
|
|
UCharacterMovementComponent_SetAvoidanceGroup_Params params;
|
|
params.GroupFlags = GroupFlags;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.SetAvoidanceEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::SetAvoidanceEnabled(bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.SetAvoidanceEnabled");
|
|
|
|
UCharacterMovementComponent_SetAvoidanceEnabled_Params params;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ServerMoveOld
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// float OldTimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector_NetQuantize10 OldAccel (Parm)
|
|
// unsigned char OldMoveFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ServerMoveOld(float OldTimeStamp, const struct FVector_NetQuantize10& OldAccel, unsigned char OldMoveFlags)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ServerMoveOld");
|
|
|
|
UCharacterMovementComponent_ServerMoveOld_Params params;
|
|
params.OldTimeStamp = OldTimeStamp;
|
|
params.OldAccel = OldAccel;
|
|
params.OldMoveFlags = OldMoveFlags;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ServerMoveDualHybridRootMotion
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// float TimeStamp0 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector_NetQuantize10 InAccel0 (Parm)
|
|
// unsigned char PendingFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
// uint32_t View0 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector_NetQuantize10 InAccel (Parm)
|
|
// struct FVector_NetQuantize100 ClientLoc (Parm)
|
|
// unsigned char NewFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ClientRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// uint32_t View (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* ClientMovementBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName ClientBaseBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ClientMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ServerMoveDualHybridRootMotion(float TimeStamp0, const struct FVector_NetQuantize10& InAccel0, unsigned char PendingFlags, uint32_t View0, float TimeStamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, unsigned char NewFlags, unsigned char ClientRoll, uint32_t View, class UPrimitiveComponent* ClientMovementBase, const struct FName& ClientBaseBoneName, unsigned char ClientMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ServerMoveDualHybridRootMotion");
|
|
|
|
UCharacterMovementComponent_ServerMoveDualHybridRootMotion_Params params;
|
|
params.TimeStamp0 = TimeStamp0;
|
|
params.InAccel0 = InAccel0;
|
|
params.PendingFlags = PendingFlags;
|
|
params.View0 = View0;
|
|
params.TimeStamp = TimeStamp;
|
|
params.InAccel = InAccel;
|
|
params.ClientLoc = ClientLoc;
|
|
params.NewFlags = NewFlags;
|
|
params.ClientRoll = ClientRoll;
|
|
params.View = View;
|
|
params.ClientMovementBase = ClientMovementBase;
|
|
params.ClientBaseBoneName = ClientBaseBoneName;
|
|
params.ClientMovementMode = ClientMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ServerMoveDual
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// float TimeStamp0 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector_NetQuantize10 InAccel0 (Parm)
|
|
// unsigned char PendingFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
// uint32_t View0 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector_NetQuantize10 InAccel (Parm)
|
|
// struct FVector_NetQuantize100 ClientLoc (Parm)
|
|
// unsigned char NewFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ClientRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// uint32_t View (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* ClientMovementBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName ClientBaseBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ClientMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ServerMoveDual(float TimeStamp0, const struct FVector_NetQuantize10& InAccel0, unsigned char PendingFlags, uint32_t View0, float TimeStamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, unsigned char NewFlags, unsigned char ClientRoll, uint32_t View, class UPrimitiveComponent* ClientMovementBase, const struct FName& ClientBaseBoneName, unsigned char ClientMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ServerMoveDual");
|
|
|
|
UCharacterMovementComponent_ServerMoveDual_Params params;
|
|
params.TimeStamp0 = TimeStamp0;
|
|
params.InAccel0 = InAccel0;
|
|
params.PendingFlags = PendingFlags;
|
|
params.View0 = View0;
|
|
params.TimeStamp = TimeStamp;
|
|
params.InAccel = InAccel;
|
|
params.ClientLoc = ClientLoc;
|
|
params.NewFlags = NewFlags;
|
|
params.ClientRoll = ClientRoll;
|
|
params.View = View;
|
|
params.ClientMovementBase = ClientMovementBase;
|
|
params.ClientBaseBoneName = ClientBaseBoneName;
|
|
params.ClientMovementMode = ClientMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ServerMove
|
|
// (Net, Native, Event, Public, NetServer, NetValidate)
|
|
// Parameters:
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector_NetQuantize10 InAccel (Parm)
|
|
// struct FVector_NetQuantize100 ClientLoc (Parm)
|
|
// unsigned char CompressedMoveFlags (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ClientRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// uint32_t View (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* ClientMovementBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName ClientBaseBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ClientMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ServerMove(float TimeStamp, const struct FVector_NetQuantize10& InAccel, const struct FVector_NetQuantize100& ClientLoc, unsigned char CompressedMoveFlags, unsigned char ClientRoll, uint32_t View, class UPrimitiveComponent* ClientMovementBase, const struct FName& ClientBaseBoneName, unsigned char ClientMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ServerMove");
|
|
|
|
UCharacterMovementComponent_ServerMove_Params params;
|
|
params.TimeStamp = TimeStamp;
|
|
params.InAccel = InAccel;
|
|
params.ClientLoc = ClientLoc;
|
|
params.CompressedMoveFlags = CompressedMoveFlags;
|
|
params.ClientRoll = ClientRoll;
|
|
params.View = View;
|
|
params.ClientMovementBase = ClientMovementBase;
|
|
params.ClientBaseBoneName = ClientBaseBoneName;
|
|
params.ClientMovementMode = ClientMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.K2_GetWalkableFloorZ
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::K2_GetWalkableFloorZ()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.K2_GetWalkableFloorZ");
|
|
|
|
UCharacterMovementComponent_K2_GetWalkableFloorZ_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.K2_GetWalkableFloorAngle
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::K2_GetWalkableFloorAngle()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.K2_GetWalkableFloorAngle");
|
|
|
|
UCharacterMovementComponent_K2_GetWalkableFloorAngle_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.K2_GetModifiedMaxAcceleration
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::K2_GetModifiedMaxAcceleration()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.K2_GetModifiedMaxAcceleration");
|
|
|
|
UCharacterMovementComponent_K2_GetModifiedMaxAcceleration_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.K2_FindFloor
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector CapsuleLocation (Parm, IsPlainOldData)
|
|
// struct FFindFloorResult FloorResult (Parm, OutParm)
|
|
|
|
void UCharacterMovementComponent::K2_FindFloor(const struct FVector& CapsuleLocation, struct FFindFloorResult* FloorResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.K2_FindFloor");
|
|
|
|
UCharacterMovementComponent_K2_FindFloor_Params params;
|
|
params.CapsuleLocation = CapsuleLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (FloorResult != nullptr)
|
|
*FloorResult = params.FloorResult;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.K2_ComputeFloorDist
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector CapsuleLocation (Parm, IsPlainOldData)
|
|
// float LineDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float SweepDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float SweepRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FFindFloorResult FloorResult (Parm, OutParm)
|
|
|
|
void UCharacterMovementComponent::K2_ComputeFloorDist(const struct FVector& CapsuleLocation, float LineDistance, float SweepDistance, float SweepRadius, struct FFindFloorResult* FloorResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.K2_ComputeFloorDist");
|
|
|
|
UCharacterMovementComponent_K2_ComputeFloorDist_Params params;
|
|
params.CapsuleLocation = CapsuleLocation;
|
|
params.LineDistance = LineDistance;
|
|
params.SweepDistance = SweepDistance;
|
|
params.SweepRadius = SweepRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (FloorResult != nullptr)
|
|
*FloorResult = params.FloorResult;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.IsWalking
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCharacterMovementComponent::IsWalking()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.IsWalking");
|
|
|
|
UCharacterMovementComponent_IsWalking_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.IsWalkable
|
|
// (Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCharacterMovementComponent::IsWalkable(const struct FHitResult& Hit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.IsWalkable");
|
|
|
|
UCharacterMovementComponent_IsWalkable_Params params;
|
|
params.Hit = Hit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetValidPerchRadius
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetValidPerchRadius()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetValidPerchRadius");
|
|
|
|
UCharacterMovementComponent_GetValidPerchRadius_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetPerchRadiusThreshold
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetPerchRadiusThreshold()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetPerchRadiusThreshold");
|
|
|
|
UCharacterMovementComponent_GetPerchRadiusThreshold_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetMovementBase
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPrimitiveComponent* UCharacterMovementComponent::GetMovementBase()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetMovementBase");
|
|
|
|
UCharacterMovementComponent_GetMovementBase_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetMinAnalogSpeed
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetMinAnalogSpeed()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetMinAnalogSpeed");
|
|
|
|
UCharacterMovementComponent_GetMinAnalogSpeed_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetMaxJumpHeightWithJumpTime
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetMaxJumpHeightWithJumpTime()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetMaxJumpHeightWithJumpTime");
|
|
|
|
UCharacterMovementComponent_GetMaxJumpHeightWithJumpTime_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetMaxJumpHeight
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetMaxJumpHeight()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetMaxJumpHeight");
|
|
|
|
UCharacterMovementComponent_GetMaxJumpHeight_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetMaxBrakingDeceleration
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetMaxBrakingDeceleration()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetMaxBrakingDeceleration");
|
|
|
|
UCharacterMovementComponent_GetMaxBrakingDeceleration_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetMaxAcceleration
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetMaxAcceleration()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetMaxAcceleration");
|
|
|
|
UCharacterMovementComponent_GetMaxAcceleration_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetImpartedMovementBaseVelocity
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UCharacterMovementComponent::GetImpartedMovementBaseVelocity()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetImpartedMovementBaseVelocity");
|
|
|
|
UCharacterMovementComponent_GetImpartedMovementBaseVelocity_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetCurrentAcceleration
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UCharacterMovementComponent::GetCurrentAcceleration()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetCurrentAcceleration");
|
|
|
|
UCharacterMovementComponent_GetCurrentAcceleration_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetCharacterOwner
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class ACharacter* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ACharacter* UCharacterMovementComponent::GetCharacterOwner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetCharacterOwner");
|
|
|
|
UCharacterMovementComponent_GetCharacterOwner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.GetAnalogInputModifier
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCharacterMovementComponent::GetAnalogInputModifier()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.GetAnalogInputModifier");
|
|
|
|
UCharacterMovementComponent_GetAnalogInputModifier_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.DisableMovement
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UCharacterMovementComponent::DisableMovement()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.DisableMovement");
|
|
|
|
UCharacterMovementComponent_DisableMovement_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ClientVeryShortAdjustPosition
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewLoc (Parm, IsPlainOldData)
|
|
// class UPrimitiveComponent* NewBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName NewBaseBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHasBase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bBaseRelativePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ServerMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ClientVeryShortAdjustPosition(float TimeStamp, const struct FVector& NewLoc, class UPrimitiveComponent* NewBase, const struct FName& NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned char ServerMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ClientVeryShortAdjustPosition");
|
|
|
|
UCharacterMovementComponent_ClientVeryShortAdjustPosition_Params params;
|
|
params.TimeStamp = TimeStamp;
|
|
params.NewLoc = NewLoc;
|
|
params.NewBase = NewBase;
|
|
params.NewBaseBoneName = NewBaseBoneName;
|
|
params.bHasBase = bHasBase;
|
|
params.bBaseRelativePosition = bBaseRelativePosition;
|
|
params.ServerMovementMode = ServerMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ClientAdjustRootMotionSourcePosition
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRootMotionSourceGroup ServerRootMotion (Parm)
|
|
// bool bHasAnimRootMotion (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ServerMontageTrackPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ServerLoc (Parm, IsPlainOldData)
|
|
// struct FVector_NetQuantizeNormal ServerRotation (Parm)
|
|
// float ServerVelZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* ServerBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName ServerBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHasBase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bBaseRelativePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ServerMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ClientAdjustRootMotionSourcePosition(float TimeStamp, const struct FRootMotionSourceGroup& ServerRootMotion, bool bHasAnimRootMotion, float ServerMontageTrackPosition, const struct FVector& ServerLoc, const struct FVector_NetQuantizeNormal& ServerRotation, float ServerVelZ, class UPrimitiveComponent* ServerBase, const struct FName& ServerBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned char ServerMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ClientAdjustRootMotionSourcePosition");
|
|
|
|
UCharacterMovementComponent_ClientAdjustRootMotionSourcePosition_Params params;
|
|
params.TimeStamp = TimeStamp;
|
|
params.ServerRootMotion = ServerRootMotion;
|
|
params.bHasAnimRootMotion = bHasAnimRootMotion;
|
|
params.ServerMontageTrackPosition = ServerMontageTrackPosition;
|
|
params.ServerLoc = ServerLoc;
|
|
params.ServerRotation = ServerRotation;
|
|
params.ServerVelZ = ServerVelZ;
|
|
params.ServerBase = ServerBase;
|
|
params.ServerBoneName = ServerBoneName;
|
|
params.bHasBase = bHasBase;
|
|
params.bBaseRelativePosition = bBaseRelativePosition;
|
|
params.ServerMovementMode = ServerMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ClientAdjustRootMotionPosition
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ServerMontageTrackPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ServerLoc (Parm, IsPlainOldData)
|
|
// struct FVector_NetQuantizeNormal ServerRotation (Parm)
|
|
// float ServerVelZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* ServerBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName ServerBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHasBase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bBaseRelativePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ServerMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ClientAdjustRootMotionPosition(float TimeStamp, float ServerMontageTrackPosition, const struct FVector& ServerLoc, const struct FVector_NetQuantizeNormal& ServerRotation, float ServerVelZ, class UPrimitiveComponent* ServerBase, const struct FName& ServerBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned char ServerMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ClientAdjustRootMotionPosition");
|
|
|
|
UCharacterMovementComponent_ClientAdjustRootMotionPosition_Params params;
|
|
params.TimeStamp = TimeStamp;
|
|
params.ServerMontageTrackPosition = ServerMontageTrackPosition;
|
|
params.ServerLoc = ServerLoc;
|
|
params.ServerRotation = ServerRotation;
|
|
params.ServerVelZ = ServerVelZ;
|
|
params.ServerBase = ServerBase;
|
|
params.ServerBoneName = ServerBoneName;
|
|
params.bHasBase = bHasBase;
|
|
params.bBaseRelativePosition = bBaseRelativePosition;
|
|
params.ServerMovementMode = ServerMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ClientAdjustPosition
|
|
// (Net, Native, Event, Public, HasDefaults, NetClient)
|
|
// Parameters:
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewLoc (Parm, IsPlainOldData)
|
|
// struct FVector NewVel (Parm, IsPlainOldData)
|
|
// class UPrimitiveComponent* NewBase (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName NewBaseBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHasBase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bBaseRelativePosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ServerMovementMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ClientAdjustPosition(float TimeStamp, const struct FVector& NewLoc, const struct FVector& NewVel, class UPrimitiveComponent* NewBase, const struct FName& NewBaseBoneName, bool bHasBase, bool bBaseRelativePosition, unsigned char ServerMovementMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ClientAdjustPosition");
|
|
|
|
UCharacterMovementComponent_ClientAdjustPosition_Params params;
|
|
params.TimeStamp = TimeStamp;
|
|
params.NewLoc = NewLoc;
|
|
params.NewVel = NewVel;
|
|
params.NewBase = NewBase;
|
|
params.NewBaseBoneName = NewBaseBoneName;
|
|
params.bHasBase = bHasBase;
|
|
params.bBaseRelativePosition = bBaseRelativePosition;
|
|
params.ServerMovementMode = ServerMovementMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ClientAckGoodMove
|
|
// (Net, Native, Event, Public, NetClient)
|
|
// Parameters:
|
|
// float TimeStamp (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::ClientAckGoodMove(float TimeStamp)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ClientAckGoodMove");
|
|
|
|
UCharacterMovementComponent_ClientAckGoodMove_Params params;
|
|
params.TimeStamp = TimeStamp;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.ClearAccumulatedForces
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UCharacterMovementComponent::ClearAccumulatedForces()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.ClearAccumulatedForces");
|
|
|
|
UCharacterMovementComponent_ClearAccumulatedForces_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.CapsuleTouched
|
|
// (Native, Protected, HasOutParms)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* OverlappedComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class AActor* Other (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* OtherComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// int OtherBodyIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFromSweep (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult SweepResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::CapsuleTouched(class UPrimitiveComponent* OverlappedComp, class AActor* Other, class UPrimitiveComponent* OtherComp, int OtherBodyIndex, bool bFromSweep, const struct FHitResult& SweepResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.CapsuleTouched");
|
|
|
|
UCharacterMovementComponent_CapsuleTouched_Params params;
|
|
params.OverlappedComp = OverlappedComp;
|
|
params.Other = Other;
|
|
params.OtherComp = OtherComp;
|
|
params.OtherBodyIndex = OtherBodyIndex;
|
|
params.bFromSweep = bFromSweep;
|
|
params.SweepResult = SweepResult;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.CalcVelocity
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Friction (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFluid (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BrakingDeceleration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::CalcVelocity(float DeltaTime, float Friction, bool bFluid, float BrakingDeceleration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.CalcVelocity");
|
|
|
|
UCharacterMovementComponent_CalcVelocity_Params params;
|
|
params.DeltaTime = DeltaTime;
|
|
params.Friction = Friction;
|
|
params.bFluid = bFluid;
|
|
params.BrakingDeceleration = BrakingDeceleration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.AddImpulse
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// bool bVelocityChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::AddImpulse(const struct FVector& Impulse, bool bVelocityChange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.AddImpulse");
|
|
|
|
UCharacterMovementComponent_AddImpulse_Params params;
|
|
params.Impulse = Impulse;
|
|
params.bVelocityChange = bVelocityChange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CharacterMovementComponent.AddForce
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector force (Parm, IsPlainOldData)
|
|
|
|
void UCharacterMovementComponent::AddForce(const struct FVector& force)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CharacterMovementComponent.AddForce");
|
|
|
|
UCharacterMovementComponent_AddForce_Params params;
|
|
params.force = force;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraShake.ReceiveStopShake
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// bool bImmediately (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraShake::ReceiveStopShake(bool bImmediately)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraShake.ReceiveStopShake");
|
|
|
|
UCameraShake_ReceiveStopShake_Params params;
|
|
params.bImmediately = bImmediately;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraShake.ReceiveRestart
|
|
// (Event, Public, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerCameraManager* Camera (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECameraAnimPlaySpace> InPlaySpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator UserPlaySpaceRot (Parm, IsPlainOldData)
|
|
|
|
void UCameraShake::ReceiveRestart(class APlayerCameraManager* Camera, float Scale, TEnumAsByte<ECameraAnimPlaySpace> InPlaySpace, const struct FRotator& UserPlaySpaceRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraShake.ReceiveRestart");
|
|
|
|
UCameraShake_ReceiveRestart_Params params;
|
|
params.Camera = Camera;
|
|
params.Scale = Scale;
|
|
params.InPlaySpace = InPlaySpace;
|
|
params.UserPlaySpaceRot = UserPlaySpaceRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraShake.ReceivePlayShake
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraShake::ReceivePlayShake(float Scale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraShake.ReceivePlayShake");
|
|
|
|
UCameraShake_ReceivePlayShake_Params params;
|
|
params.Scale = Scale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraShake.ReceiveIsFinished
|
|
// (Native, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCameraShake::ReceiveIsFinished()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraShake.ReceiveIsFinished");
|
|
|
|
UCameraShake_ReceiveIsFinished_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraShake.BlueprintUpdateCameraShake
|
|
// (Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FMinimalViewInfo POV (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FMinimalViewInfo ModifiedPOV (Parm, OutParm)
|
|
|
|
void UCameraShake::BlueprintUpdateCameraShake(float DeltaTime, float alpha, const struct FMinimalViewInfo& POV, struct FMinimalViewInfo* ModifiedPOV)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraShake.BlueprintUpdateCameraShake");
|
|
|
|
UCameraShake_BlueprintUpdateCameraShake_Params params;
|
|
params.DeltaTime = DeltaTime;
|
|
params.alpha = alpha;
|
|
params.POV = POV;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ModifiedPOV != nullptr)
|
|
*ModifiedPOV = params.ModifiedPOV;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.UnHideBoneByName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::UnHideBoneByName(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.UnHideBoneByName");
|
|
|
|
USkinnedMeshComponent_UnHideBoneByName_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.TransformToBoneSpace
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InPosition (Parm, IsPlainOldData)
|
|
// struct FRotator InRotation (Parm, IsPlainOldData)
|
|
// struct FVector OutPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator OutRotation (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::TransformToBoneSpace(const struct FName& BoneName, const struct FVector& InPosition, const struct FRotator& InRotation, struct FVector* OutPosition, struct FRotator* OutRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.TransformToBoneSpace");
|
|
|
|
USkinnedMeshComponent_TransformToBoneSpace_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InPosition = InPosition;
|
|
params.InRotation = InRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutPosition != nullptr)
|
|
*OutPosition = params.OutPosition;
|
|
if (OutRotation != nullptr)
|
|
*OutRotation = params.OutRotation;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.TransformFromBoneSpace
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InPosition (Parm, IsPlainOldData)
|
|
// struct FRotator InRotation (Parm, IsPlainOldData)
|
|
// struct FVector OutPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator OutRotation (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::TransformFromBoneSpace(const struct FName& BoneName, const struct FVector& InPosition, const struct FRotator& InRotation, struct FVector* OutPosition, struct FRotator* OutRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.TransformFromBoneSpace");
|
|
|
|
USkinnedMeshComponent_TransformFromBoneSpace_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InPosition = InPosition;
|
|
params.InRotation = InRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutPosition != nullptr)
|
|
*OutPosition = params.OutPosition;
|
|
if (OutRotation != nullptr)
|
|
*OutRotation = params.OutRotation;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetVertexColorOverride_LinearColor
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FLinearColor> VertexColors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void USkinnedMeshComponent::SetVertexColorOverride_LinearColor(int LODIndex, TArray<struct FLinearColor> VertexColors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetVertexColorOverride_LinearColor");
|
|
|
|
USkinnedMeshComponent_SetVertexColorOverride_LinearColor_Params params;
|
|
params.LODIndex = LODIndex;
|
|
params.VertexColors = VertexColors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetSkinWeightOverride
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FSkelMeshSkinWeightInfo> SkinWeights (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void USkinnedMeshComponent::SetSkinWeightOverride(int LODIndex, TArray<struct FSkelMeshSkinWeightInfo> SkinWeights)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetSkinWeightOverride");
|
|
|
|
USkinnedMeshComponent_SetSkinWeightOverride_Params params;
|
|
params.LODIndex = LODIndex;
|
|
params.SkinWeights = SkinWeights;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetSkeletalMesh
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USkeletalMesh* NewMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bReinitPose (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetSkeletalMesh(class USkeletalMesh* NewMesh, bool bReinitPose)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetSkeletalMesh");
|
|
|
|
USkinnedMeshComponent_SetSkeletalMesh_Params params;
|
|
params.NewMesh = NewMesh;
|
|
params.bReinitPose = bReinitPose;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetPhysicsAsset
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPhysicsAsset* NewPhysicsAsset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bForceReInit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetPhysicsAsset(class UPhysicsAsset* NewPhysicsAsset, bool bForceReInit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetPhysicsAsset");
|
|
|
|
USkinnedMeshComponent_SetPhysicsAsset_Params params;
|
|
params.NewPhysicsAsset = NewPhysicsAsset;
|
|
params.bForceReInit = bForceReInit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetMinLOD
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InNewMinLOD (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetMinLOD(int InNewMinLOD)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetMinLOD");
|
|
|
|
USkinnedMeshComponent_SetMinLOD_Params params;
|
|
params.InNewMinLOD = InNewMinLOD;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetMasterPoseComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USkinnedMeshComponent* NewMasterBoneComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetMasterPoseComponent(class USkinnedMeshComponent* NewMasterBoneComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetMasterPoseComponent");
|
|
|
|
USkinnedMeshComponent_SetMasterPoseComponent_Params params;
|
|
params.NewMasterBoneComponent = NewMasterBoneComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetForcedLOD
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InNewForcedLOD (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetForcedLOD(int InNewForcedLOD)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetForcedLOD");
|
|
|
|
USkinnedMeshComponent_SetForcedLOD_Params params;
|
|
params.InNewForcedLOD = InNewForcedLOD;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetCastCapsuleIndirectShadow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetCastCapsuleIndirectShadow(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetCastCapsuleIndirectShadow");
|
|
|
|
USkinnedMeshComponent_SetCastCapsuleIndirectShadow_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetCastCapsuleDirectShadow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetCastCapsuleDirectShadow(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetCastCapsuleDirectShadow");
|
|
|
|
USkinnedMeshComponent_SetCastCapsuleDirectShadow_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.SetCapsuleIndirectShadowMinVisibility
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::SetCapsuleIndirectShadowMinVisibility(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.SetCapsuleIndirectShadowMinVisibility");
|
|
|
|
USkinnedMeshComponent_SetCapsuleIndirectShadowMinVisibility_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.IsBoneHiddenByName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkinnedMeshComponent::IsBoneHiddenByName(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.IsBoneHiddenByName");
|
|
|
|
USkinnedMeshComponent_IsBoneHiddenByName_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.HideBoneByName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EPhysBodyOp> PhysBodyOption (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::HideBoneByName(const struct FName& BoneName, TEnumAsByte<EPhysBodyOp> PhysBodyOption)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.HideBoneByName");
|
|
|
|
USkinnedMeshComponent_HideBoneByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.PhysBodyOption = PhysBodyOption;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.GetSocketBoneName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName USkinnedMeshComponent::GetSocketBoneName(const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.GetSocketBoneName");
|
|
|
|
USkinnedMeshComponent_GetSocketBoneName_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.GetParentBone
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName USkinnedMeshComponent::GetParentBone(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.GetParentBone");
|
|
|
|
USkinnedMeshComponent_GetParentBone_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.GetNumBones
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int USkinnedMeshComponent::GetNumBones()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.GetNumBones");
|
|
|
|
USkinnedMeshComponent_GetNumBones_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.GetBoneName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int BoneIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName USkinnedMeshComponent::GetBoneName(int BoneIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.GetBoneName");
|
|
|
|
USkinnedMeshComponent_GetBoneName_Params params;
|
|
params.BoneIndex = BoneIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.GetBoneIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int USkinnedMeshComponent::GetBoneIndex(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.GetBoneIndex");
|
|
|
|
USkinnedMeshComponent_GetBoneIndex_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.FindClosestBone_K2
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector TestLocation (Parm, IsPlainOldData)
|
|
// struct FVector BoneLocation (Parm, OutParm, IsPlainOldData)
|
|
// float IgnoreScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRequirePhysicsAsset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName USkinnedMeshComponent::FindClosestBone_K2(const struct FVector& TestLocation, float IgnoreScale, bool bRequirePhysicsAsset, struct FVector* BoneLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.FindClosestBone_K2");
|
|
|
|
USkinnedMeshComponent_FindClosestBone_K2_Params params;
|
|
params.TestLocation = TestLocation;
|
|
params.IgnoreScale = IgnoreScale;
|
|
params.bRequirePhysicsAsset = bRequirePhysicsAsset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (BoneLocation != nullptr)
|
|
*BoneLocation = params.BoneLocation;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.ClearVertexColorOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::ClearVertexColorOverride(int LODIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.ClearVertexColorOverride");
|
|
|
|
USkinnedMeshComponent_ClearVertexColorOverride_Params params;
|
|
params.LODIndex = LODIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.ClearSkinWeightOverride
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int LODIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkinnedMeshComponent::ClearSkinWeightOverride(int LODIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.ClearSkinWeightOverride");
|
|
|
|
USkinnedMeshComponent_ClearSkinWeightOverride_Params params;
|
|
params.LODIndex = LODIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkinnedMeshComponent.BoneIsChildOf
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ParentBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkinnedMeshComponent::BoneIsChildOf(const struct FName& BoneName, const struct FName& ParentBoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkinnedMeshComponent.BoneIsChildOf");
|
|
|
|
USkinnedMeshComponent_BoneIsChildOf_Params params;
|
|
params.BoneName = BoneName;
|
|
params.ParentBoneName = ParentBoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.UnbindClothFromMasterPoseComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bRestoreSimulationSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::UnbindClothFromMasterPoseComponent(bool bRestoreSimulationSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.UnbindClothFromMasterPoseComponent");
|
|
|
|
USkeletalMeshComponent_UnbindClothFromMasterPoseComponent_Params params;
|
|
params.bRestoreSimulationSpace = bRestoreSimulationSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SuspendClothingSimulation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::SuspendClothingSimulation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SuspendClothingSimulation");
|
|
|
|
USkeletalMeshComponent_SuspendClothingSimulation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.Stop
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.Stop");
|
|
|
|
USkeletalMeshComponent_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SnapshotPose
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPoseSnapshot Snapshot (Parm, OutParm, ReferenceParm)
|
|
|
|
void USkeletalMeshComponent::SnapshotPose(struct FPoseSnapshot* Snapshot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SnapshotPose");
|
|
|
|
USkeletalMeshComponent_SnapshotPose_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Snapshot != nullptr)
|
|
*Snapshot = params.Snapshot;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetUpdateAnimationInEditor
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewUpdateState (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetUpdateAnimationInEditor(bool NewUpdateState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetUpdateAnimationInEditor");
|
|
|
|
USkeletalMeshComponent_SetUpdateAnimationInEditor_Params params;
|
|
params.NewUpdateState = NewUpdateState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetTeleportRotationThreshold
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Threshold (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetTeleportRotationThreshold(float Threshold)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetTeleportRotationThreshold");
|
|
|
|
USkeletalMeshComponent_SetTeleportRotationThreshold_Params params;
|
|
params.Threshold = Threshold;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetTeleportDistanceThreshold
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Threshold (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetTeleportDistanceThreshold(float Threshold)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetTeleportDistanceThreshold");
|
|
|
|
USkeletalMeshComponent_SetTeleportDistanceThreshold_Params params;
|
|
params.Threshold = Threshold;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetPosition
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPos (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFireNotifies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetPosition(float InPos, bool bFireNotifies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetPosition");
|
|
|
|
USkeletalMeshComponent_SetPosition_Params params;
|
|
params.InPos = InPos;
|
|
params.bFireNotifies = bFireNotifies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetPlayRate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Rate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetPlayRate(float Rate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetPlayRate");
|
|
|
|
USkeletalMeshComponent_SetPlayRate_Params params;
|
|
params.Rate = Rate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetPhysicsBlendWeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float PhysicsBlendWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetPhysicsBlendWeight(float PhysicsBlendWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetPhysicsBlendWeight");
|
|
|
|
USkeletalMeshComponent_SetPhysicsBlendWeight_Params params;
|
|
params.PhysicsBlendWeight = PhysicsBlendWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetNotifyRigidBodyCollisionBelow
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewNotifyRigidBodyCollision (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetNotifyRigidBodyCollisionBelow(bool bNewNotifyRigidBodyCollision, const struct FName& BoneName, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetNotifyRigidBodyCollisionBelow");
|
|
|
|
USkeletalMeshComponent_SetNotifyRigidBodyCollisionBelow_Params params;
|
|
params.bNewNotifyRigidBodyCollision = bNewNotifyRigidBodyCollision;
|
|
params.BoneName = BoneName;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetMorphTarget
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName MorphTargetName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRemoveZeroWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetMorphTarget(const struct FName& MorphTargetName, float Value, bool bRemoveZeroWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetMorphTarget");
|
|
|
|
USkeletalMeshComponent_SetMorphTarget_Params params;
|
|
params.MorphTargetName = MorphTargetName;
|
|
params.Value = Value;
|
|
params.bRemoveZeroWeight = bRemoveZeroWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetEnablePhysicsBlending
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewBlendPhysics (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetEnablePhysicsBlending(bool bNewBlendPhysics)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetEnablePhysicsBlending");
|
|
|
|
USkeletalMeshComponent_SetEnablePhysicsBlending_Params params;
|
|
params.bNewBlendPhysics = bNewBlendPhysics;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetEnableGravityOnAllBodiesBelow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableGravity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetEnableGravityOnAllBodiesBelow(bool bEnableGravity, const struct FName& BoneName, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetEnableGravityOnAllBodiesBelow");
|
|
|
|
USkeletalMeshComponent_SetEnableGravityOnAllBodiesBelow_Params params;
|
|
params.bEnableGravity = bEnableGravity;
|
|
params.BoneName = BoneName;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetEnableBodyGravity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableGravity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetEnableBodyGravity(bool bEnableGravity, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetEnableBodyGravity");
|
|
|
|
USkeletalMeshComponent_SetEnableBodyGravity_Params params;
|
|
params.bEnableGravity = bEnableGravity;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetDisableAnimCurves
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInDisableAnimCurves (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetDisableAnimCurves(bool bInDisableAnimCurves)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetDisableAnimCurves");
|
|
|
|
USkeletalMeshComponent_SetDisableAnimCurves_Params params;
|
|
params.bInDisableAnimCurves = bInDisableAnimCurves;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetConstraintProfileForAll
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDefaultIfNotFound (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetConstraintProfileForAll(const struct FName& ProfileName, bool bDefaultIfNotFound)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetConstraintProfileForAll");
|
|
|
|
USkeletalMeshComponent_SetConstraintProfileForAll_Params params;
|
|
params.ProfileName = ProfileName;
|
|
params.bDefaultIfNotFound = bDefaultIfNotFound;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetConstraintProfile
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName JointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDefaultIfNotFound (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetConstraintProfile(const struct FName& JointName, const struct FName& ProfileName, bool bDefaultIfNotFound)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetConstraintProfile");
|
|
|
|
USkeletalMeshComponent_SetConstraintProfile_Params params;
|
|
params.JointName = JointName;
|
|
params.ProfileName = ProfileName;
|
|
params.bDefaultIfNotFound = bDefaultIfNotFound;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetClothMaxDistanceScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetClothMaxDistanceScale(float Scale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetClothMaxDistanceScale");
|
|
|
|
USkeletalMeshComponent_SetClothMaxDistanceScale_Params params;
|
|
params.Scale = Scale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetBodyNotifyRigidBodyCollision
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewNotifyRigidBodyCollision (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetBodyNotifyRigidBodyCollision(bool bNewNotifyRigidBodyCollision, const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetBodyNotifyRigidBodyCollision");
|
|
|
|
USkeletalMeshComponent_SetBodyNotifyRigidBodyCollision_Params params;
|
|
params.bNewNotifyRigidBodyCollision = bNewNotifyRigidBodyCollision;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAnimInstanceClass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* NewClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAnimInstanceClass(class UClass* NewClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAnimInstanceClass");
|
|
|
|
USkeletalMeshComponent_SetAnimInstanceClass_Params params;
|
|
params.NewClass = NewClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAnimationMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EAnimationMode> InAnimationMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAnimationMode(TEnumAsByte<EAnimationMode> InAnimationMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAnimationMode");
|
|
|
|
USkeletalMeshComponent_SetAnimationMode_Params params;
|
|
params.InAnimationMode = InAnimationMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAnimation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimationAsset* NewAnimToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAnimation(class UAnimationAsset* NewAnimToPlay)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAnimation");
|
|
|
|
USkeletalMeshComponent_SetAnimation_Params params;
|
|
params.NewAnimToPlay = NewAnimToPlay;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAngularLimits
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Swing1LimitAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TwistLimitAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Swing2LimitAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAngularLimits(const struct FName& InBoneName, float Swing1LimitAngle, float TwistLimitAngle, float Swing2LimitAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAngularLimits");
|
|
|
|
USkeletalMeshComponent_SetAngularLimits_Params params;
|
|
params.InBoneName = InBoneName;
|
|
params.Swing1LimitAngle = Swing1LimitAngle;
|
|
params.TwistLimitAngle = TwistLimitAngle;
|
|
params.Swing2LimitAngle = Swing2LimitAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllowedAnimCurvesEvaluation
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FName> List (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bAllow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllowedAnimCurvesEvaluation(TArray<struct FName> List, bool bAllow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllowedAnimCurvesEvaluation");
|
|
|
|
USkeletalMeshComponent_SetAllowedAnimCurvesEvaluation_Params params;
|
|
params.List = List;
|
|
params.bAllow = bAllow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllowAnimCurveEvaluation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInAllow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllowAnimCurveEvaluation(bool bInAllow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllowAnimCurveEvaluation");
|
|
|
|
USkeletalMeshComponent_SetAllowAnimCurveEvaluation_Params params;
|
|
params.bInAllow = bInAllow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllMotorsAngularVelocityDrive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableSwingDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableTwistDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSkipCustomPhysicsType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllMotorsAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllMotorsAngularVelocityDrive");
|
|
|
|
USkeletalMeshComponent_SetAllMotorsAngularVelocityDrive_Params params;
|
|
params.bEnableSwingDrive = bEnableSwingDrive;
|
|
params.bEnableTwistDrive = bEnableTwistDrive;
|
|
params.bSkipCustomPhysicsType = bSkipCustomPhysicsType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllMotorsAngularPositionDrive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableSwingDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableTwistDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSkipCustomPhysicsType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllMotorsAngularPositionDrive(bool bEnableSwingDrive, bool bEnableTwistDrive, bool bSkipCustomPhysicsType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllMotorsAngularPositionDrive");
|
|
|
|
USkeletalMeshComponent_SetAllMotorsAngularPositionDrive_Params params;
|
|
params.bEnableSwingDrive = bEnableSwingDrive;
|
|
params.bEnableTwistDrive = bEnableTwistDrive;
|
|
params.bSkipCustomPhysicsType = bSkipCustomPhysicsType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllMotorsAngularDriveParams
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InSpring (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InDamping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InForceLimit (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSkipCustomPhysicsType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllMotorsAngularDriveParams(float InSpring, float InDamping, float InForceLimit, bool bSkipCustomPhysicsType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllMotorsAngularDriveParams");
|
|
|
|
USkeletalMeshComponent_SetAllMotorsAngularDriveParams_Params params;
|
|
params.InSpring = InSpring;
|
|
params.InDamping = InDamping;
|
|
params.InForceLimit = InForceLimit;
|
|
params.bSkipCustomPhysicsType = bSkipCustomPhysicsType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllBodiesSimulatePhysics
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewSimulate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllBodiesSimulatePhysics(bool bNewSimulate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllBodiesSimulatePhysics");
|
|
|
|
USkeletalMeshComponent_SetAllBodiesSimulatePhysics_Params params;
|
|
params.bNewSimulate = bNewSimulate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllBodiesPhysicsBlendWeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float PhysicsBlendWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSkipCustomPhysicsType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllBodiesPhysicsBlendWeight(float PhysicsBlendWeight, bool bSkipCustomPhysicsType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllBodiesPhysicsBlendWeight");
|
|
|
|
USkeletalMeshComponent_SetAllBodiesPhysicsBlendWeight_Params params;
|
|
params.PhysicsBlendWeight = PhysicsBlendWeight;
|
|
params.bSkipCustomPhysicsType = bSkipCustomPhysicsType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllBodiesBelowSimulatePhysics
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InBoneName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool bNewSimulate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllBodiesBelowSimulatePhysics(const struct FName& InBoneName, bool bNewSimulate, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllBodiesBelowSimulatePhysics");
|
|
|
|
USkeletalMeshComponent_SetAllBodiesBelowSimulatePhysics_Params params;
|
|
params.InBoneName = InBoneName;
|
|
params.bNewSimulate = bNewSimulate;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.SetAllBodiesBelowPhysicsBlendWeight
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InBoneName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// float PhysicsBlendWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSkipCustomPhysicsType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::SetAllBodiesBelowPhysicsBlendWeight(const struct FName& InBoneName, float PhysicsBlendWeight, bool bSkipCustomPhysicsType, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.SetAllBodiesBelowPhysicsBlendWeight");
|
|
|
|
USkeletalMeshComponent_SetAllBodiesBelowPhysicsBlendWeight_Params params;
|
|
params.InBoneName = InBoneName;
|
|
params.PhysicsBlendWeight = PhysicsBlendWeight;
|
|
params.bSkipCustomPhysicsType = bSkipCustomPhysicsType;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ResumeClothingSimulation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ResumeClothingSimulation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ResumeClothingSimulation");
|
|
|
|
USkeletalMeshComponent_ResumeClothingSimulation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ResetClothTeleportMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ResetClothTeleportMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ResetClothTeleportMode");
|
|
|
|
USkeletalMeshComponent_ResetClothTeleportMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ResetAllowedAnimCurveEvaluation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ResetAllowedAnimCurveEvaluation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ResetAllowedAnimCurveEvaluation");
|
|
|
|
USkeletalMeshComponent_ResetAllowedAnimCurveEvaluation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ResetAllBodiesSimulatePhysics
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ResetAllBodiesSimulatePhysics()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ResetAllBodiesSimulatePhysics");
|
|
|
|
USkeletalMeshComponent_ResetAllBodiesSimulatePhysics_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.PlayAnimation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimationAsset* NewAnimToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::PlayAnimation(class UAnimationAsset* NewAnimToPlay, bool bLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.PlayAnimation");
|
|
|
|
USkeletalMeshComponent_PlayAnimation_Params params;
|
|
params.NewAnimToPlay = NewAnimToPlay;
|
|
params.bLooping = bLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.Play
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::Play(bool bLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.Play");
|
|
|
|
USkeletalMeshComponent_Play_Params params;
|
|
params.bLooping = bLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.OverrideAnimationData
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimationAsset* InAnimToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsPlaying (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Position (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::OverrideAnimationData(class UAnimationAsset* InAnimToPlay, bool bIsLooping, bool bIsPlaying, float Position, float PlayRate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.OverrideAnimationData");
|
|
|
|
USkeletalMeshComponent_OverrideAnimationData_Params params;
|
|
params.InAnimToPlay = InAnimToPlay;
|
|
params.bIsLooping = bIsLooping;
|
|
params.bIsPlaying = bIsPlaying;
|
|
params.Position = Position;
|
|
params.PlayRate = PlayRate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.K2_GetClosestPointOnPhysicsAsset
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldPosition (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector ClosestWorldPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Normal (Parm, OutParm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Distance (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMeshComponent::K2_GetClosestPointOnPhysicsAsset(const struct FVector& WorldPosition, struct FVector* ClosestWorldPosition, struct FVector* Normal, struct FName* BoneName, float* Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.K2_GetClosestPointOnPhysicsAsset");
|
|
|
|
USkeletalMeshComponent_K2_GetClosestPointOnPhysicsAsset_Params params;
|
|
params.WorldPosition = WorldPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ClosestWorldPosition != nullptr)
|
|
*ClosestWorldPosition = params.ClosestWorldPosition;
|
|
if (Normal != nullptr)
|
|
*Normal = params.Normal;
|
|
if (BoneName != nullptr)
|
|
*BoneName = params.BoneName;
|
|
if (Distance != nullptr)
|
|
*Distance = params.Distance;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.IsPlaying
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMeshComponent::IsPlaying()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.IsPlaying");
|
|
|
|
USkeletalMeshComponent_IsPlaying_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.IsClothingSimulationSuspended
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMeshComponent::IsClothingSimulationSuspended()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.IsClothingSimulationSuspended");
|
|
|
|
USkeletalMeshComponent_IsClothingSimulationSuspended_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.IsBodyGravityEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMeshComponent::IsBodyGravityEnabled(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.IsBodyGravityEnabled");
|
|
|
|
USkeletalMeshComponent_IsBodyGravityEnabled_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetTeleportRotationThreshold
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetTeleportRotationThreshold()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetTeleportRotationThreshold");
|
|
|
|
USkeletalMeshComponent_GetTeleportRotationThreshold_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetTeleportDistanceThreshold
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetTeleportDistanceThreshold()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetTeleportDistanceThreshold");
|
|
|
|
USkeletalMeshComponent_GetTeleportDistanceThreshold_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetSubAnimInstances
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<class UAnimInstance*> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<class UAnimInstance*> USkeletalMeshComponent::GetSubAnimInstances()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetSubAnimInstances");
|
|
|
|
USkeletalMeshComponent_GetSubAnimInstances_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetSkeletalCenterOfMass
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USkeletalMeshComponent::GetSkeletalCenterOfMass()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetSkeletalCenterOfMass");
|
|
|
|
USkeletalMeshComponent_GetSkeletalCenterOfMass_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetPostProcessInstance
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimInstance* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAnimInstance* USkeletalMeshComponent::GetPostProcessInstance()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetPostProcessInstance");
|
|
|
|
USkeletalMeshComponent_GetPostProcessInstance_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetPosition
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetPosition");
|
|
|
|
USkeletalMeshComponent_GetPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetPlayRate
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetPlayRate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetPlayRate");
|
|
|
|
USkeletalMeshComponent_GetPlayRate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetMorphTarget
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName MorphTargetName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetMorphTarget(const struct FName& MorphTargetName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetMorphTarget");
|
|
|
|
USkeletalMeshComponent_GetMorphTarget_Params params;
|
|
params.MorphTargetName = MorphTargetName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetDisableAnimCurves
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMeshComponent::GetDisableAnimCurves()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetDisableAnimCurves");
|
|
|
|
USkeletalMeshComponent_GetDisableAnimCurves_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetCurrentJointAngles
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Swing1Angle (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float TwistAngle (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Swing2Angle (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::GetCurrentJointAngles(const struct FName& InBoneName, float* Swing1Angle, float* TwistAngle, float* Swing2Angle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetCurrentJointAngles");
|
|
|
|
USkeletalMeshComponent_GetCurrentJointAngles_Params params;
|
|
params.InBoneName = InBoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Swing1Angle != nullptr)
|
|
*Swing1Angle = params.Swing1Angle;
|
|
if (TwistAngle != nullptr)
|
|
*TwistAngle = params.TwistAngle;
|
|
if (Swing2Angle != nullptr)
|
|
*Swing2Angle = params.Swing2Angle;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetClothMaxDistanceScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetClothMaxDistanceScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetClothMaxDistanceScale");
|
|
|
|
USkeletalMeshComponent_GetClothMaxDistanceScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetBoneMass
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bScaleMass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USkeletalMeshComponent::GetBoneMass(const struct FName& BoneName, bool bScaleMass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetBoneMass");
|
|
|
|
USkeletalMeshComponent_GetBoneMass_Params params;
|
|
params.BoneName = BoneName;
|
|
params.bScaleMass = bScaleMass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetAnimInstance
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimInstance* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAnimInstance* USkeletalMeshComponent::GetAnimInstance()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetAnimInstance");
|
|
|
|
USkeletalMeshComponent_GetAnimInstance_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetAnimationMode
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EAnimationMode> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EAnimationMode> USkeletalMeshComponent::GetAnimationMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetAnimationMode");
|
|
|
|
USkeletalMeshComponent_GetAnimationMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.GetAllowedAnimCurveEvaluate
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMeshComponent::GetAllowedAnimCurveEvaluate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.GetAllowedAnimCurveEvaluate");
|
|
|
|
USkeletalMeshComponent_GetAllowedAnimCurveEvaluate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ForceClothNextUpdateTeleportAndReset
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ForceClothNextUpdateTeleportAndReset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ForceClothNextUpdateTeleportAndReset");
|
|
|
|
USkeletalMeshComponent_ForceClothNextUpdateTeleportAndReset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ForceClothNextUpdateTeleport
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ForceClothNextUpdateTeleport()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ForceClothNextUpdateTeleport");
|
|
|
|
USkeletalMeshComponent_ForceClothNextUpdateTeleport_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.FindConstraintBoneName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ConstraintIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName USkeletalMeshComponent::FindConstraintBoneName(int ConstraintIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.FindConstraintBoneName");
|
|
|
|
USkeletalMeshComponent_FindConstraintBoneName_Params params;
|
|
params.ConstraintIndex = ConstraintIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.ClearMorphTargets
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::ClearMorphTargets()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.ClearMorphTargets");
|
|
|
|
USkeletalMeshComponent_ClearMorphTargets_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.BreakConstraint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FVector HitLocation (Parm, IsPlainOldData)
|
|
// struct FName InBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::BreakConstraint(const struct FVector& Impulse, const struct FVector& HitLocation, const struct FName& InBoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.BreakConstraint");
|
|
|
|
USkeletalMeshComponent_BreakConstraint_Params params;
|
|
params.Impulse = Impulse;
|
|
params.HitLocation = HitLocation;
|
|
params.InBoneName = InBoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.BindClothToMasterPoseComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkeletalMeshComponent::BindClothToMasterPoseComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.BindClothToMasterPoseComponent");
|
|
|
|
USkeletalMeshComponent_BindClothToMasterPoseComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.AllowAnimCurveEvaluation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName NameOfCurve (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAllow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::AllowAnimCurveEvaluation(const struct FName& NameOfCurve, bool bAllow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.AllowAnimCurveEvaluation");
|
|
|
|
USkeletalMeshComponent_AllowAnimCurveEvaluation_Params params;
|
|
params.NameOfCurve = NameOfCurve;
|
|
params.bAllow = bAllow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.AddImpulseToAllBodiesBelow
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Impulse (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bVelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::AddImpulseToAllBodiesBelow(const struct FVector& Impulse, const struct FName& BoneName, bool bVelChange, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.AddImpulseToAllBodiesBelow");
|
|
|
|
USkeletalMeshComponent_AddImpulseToAllBodiesBelow_Params params;
|
|
params.Impulse = Impulse;
|
|
params.BoneName = BoneName;
|
|
params.bVelChange = bVelChange;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.AddForceToAllBodiesBelow
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector force (Parm, IsPlainOldData)
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAccelChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::AddForceToAllBodiesBelow(const struct FVector& force, const struct FName& BoneName, bool bAccelChange, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.AddForceToAllBodiesBelow");
|
|
|
|
USkeletalMeshComponent_AddForceToAllBodiesBelow_Params params;
|
|
params.force = force;
|
|
params.BoneName = BoneName;
|
|
params.bAccelChange = bAccelChange;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshComponent.AccumulateAllBodiesBelowPhysicsBlendWeight
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InBoneName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// float AddPhysicsBlendWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSkipCustomPhysicsType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkeletalMeshComponent::AccumulateAllBodiesBelowPhysicsBlendWeight(const struct FName& InBoneName, float AddPhysicsBlendWeight, bool bSkipCustomPhysicsType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshComponent.AccumulateAllBodiesBelowPhysicsBlendWeight");
|
|
|
|
USkeletalMeshComponent_AccumulateAllBodiesBelowPhysicsBlendWeight_Params params;
|
|
params.InBoneName = InBoneName;
|
|
params.AddPhysicsBlendWeight = AddPhysicsBlendWeight;
|
|
params.bSkipCustomPhysicsType = bSkipCustomPhysicsType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.UnlockAIResources
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bUnlockMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool UnlockAILogic (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::UnlockAIResources(bool bUnlockMovement, bool UnlockAILogic)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.UnlockAIResources");
|
|
|
|
UAnimInstance_UnlockAIResources_Params params;
|
|
params.bUnlockMovement = bUnlockMovement;
|
|
params.UnlockAILogic = UnlockAILogic;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.TryGetPawnOwner
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* UAnimInstance::TryGetPawnOwner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.TryGetPawnOwner");
|
|
|
|
UAnimInstance_TryGetPawnOwner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.StopSlotAnimation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InBlendOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SlotNodeName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::StopSlotAnimation(float InBlendOutTime, const struct FName& SlotNodeName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.StopSlotAnimation");
|
|
|
|
UAnimInstance_StopSlotAnimation_Params params;
|
|
params.InBlendOutTime = InBlendOutTime;
|
|
params.SlotNodeName = SlotNodeName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.SnapshotPose
|
|
// (Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPoseSnapshot Snapshot (Parm, OutParm, ReferenceParm)
|
|
|
|
void UAnimInstance::SnapshotPose(struct FPoseSnapshot* Snapshot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.SnapshotPose");
|
|
|
|
UAnimInstance_SnapshotPose_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Snapshot != nullptr)
|
|
*Snapshot = params.Snapshot;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.SetRootMotionMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ERootMotionMode> Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::SetRootMotionMode(TEnumAsByte<ERootMotionMode> Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.SetRootMotionMode");
|
|
|
|
UAnimInstance_SetRootMotionMode_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.SetMorphTarget
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName MorphTargetName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::SetMorphTarget(const struct FName& MorphTargetName, float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.SetMorphTarget");
|
|
|
|
UAnimInstance_SetMorphTarget_Params params;
|
|
params.MorphTargetName = MorphTargetName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.SavePoseSnapshot
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName SnapshotName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::SavePoseSnapshot(const struct FName& SnapshotName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.SavePoseSnapshot");
|
|
|
|
UAnimInstance_SavePoseSnapshot_Params params;
|
|
params.SnapshotName = SnapshotName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.PlaySlotAnimationAsDynamicMontage
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimSequenceBase* Asset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SlotNodeName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendInTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int LoopCount (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendOutTriggerTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InTimeToStartMontageAt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAnimMontage* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAnimMontage* UAnimInstance::PlaySlotAnimationAsDynamicMontage(class UAnimSequenceBase* Asset, const struct FName& SlotNodeName, float BlendInTime, float BlendOutTime, float InPlayRate, int LoopCount, float BlendOutTriggerTime, float InTimeToStartMontageAt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.PlaySlotAnimationAsDynamicMontage");
|
|
|
|
UAnimInstance_PlaySlotAnimationAsDynamicMontage_Params params;
|
|
params.Asset = Asset;
|
|
params.SlotNodeName = SlotNodeName;
|
|
params.BlendInTime = BlendInTime;
|
|
params.BlendOutTime = BlendOutTime;
|
|
params.InPlayRate = InPlayRate;
|
|
params.LoopCount = LoopCount;
|
|
params.BlendOutTriggerTime = BlendOutTriggerTime;
|
|
params.InTimeToStartMontageAt = InTimeToStartMontageAt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.PlaySlotAnimation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimSequenceBase* Asset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SlotNodeName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendInTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int LoopCount (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::PlaySlotAnimation(class UAnimSequenceBase* Asset, const struct FName& SlotNodeName, float BlendInTime, float BlendOutTime, float InPlayRate, int LoopCount)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.PlaySlotAnimation");
|
|
|
|
UAnimInstance_PlaySlotAnimation_Params params;
|
|
params.Asset = Asset;
|
|
params.SlotNodeName = SlotNodeName;
|
|
params.BlendInTime = BlendInTime;
|
|
params.BlendOutTime = BlendOutTime;
|
|
params.InPlayRate = InPlayRate;
|
|
params.LoopCount = LoopCount;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_Stop
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InBlendOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_Stop(float InBlendOutTime, class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_Stop");
|
|
|
|
UAnimInstance_Montage_Stop_Params params;
|
|
params.InBlendOutTime = InBlendOutTime;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_SetPosition
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NewPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_SetPosition(class UAnimMontage* Montage, float NewPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_SetPosition");
|
|
|
|
UAnimInstance_Montage_SetPosition_Params params;
|
|
params.Montage = Montage;
|
|
params.NewPosition = NewPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_SetPlayRate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NewPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_SetPlayRate(class UAnimMontage* Montage, float NewPlayRate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_SetPlayRate");
|
|
|
|
UAnimInstance_Montage_SetPlayRate_Params params;
|
|
params.Montage = Montage;
|
|
params.NewPlayRate = NewPlayRate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_SetNextSection
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName SectionNameToChange (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName NextSection (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_SetNextSection(const struct FName& SectionNameToChange, const struct FName& NextSection, class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_SetNextSection");
|
|
|
|
UAnimInstance_Montage_SetNextSection_Params params;
|
|
params.SectionNameToChange = SectionNameToChange;
|
|
params.NextSection = NextSection;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_Resume
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_Resume(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_Resume");
|
|
|
|
UAnimInstance_Montage_Resume_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_Play
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* MontageToPlay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// EMontagePlayReturnType ReturnValueType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InTimeToStartMontageAt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::Montage_Play(class UAnimMontage* MontageToPlay, float InPlayRate, EMontagePlayReturnType ReturnValueType, float InTimeToStartMontageAt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_Play");
|
|
|
|
UAnimInstance_Montage_Play_Params params;
|
|
params.MontageToPlay = MontageToPlay;
|
|
params.InPlayRate = InPlayRate;
|
|
params.ReturnValueType = ReturnValueType;
|
|
params.InTimeToStartMontageAt = InTimeToStartMontageAt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_Pause
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_Pause(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_Pause");
|
|
|
|
UAnimInstance_Montage_Pause_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_JumpToSectionsEnd
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName SectionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_JumpToSectionsEnd(const struct FName& SectionName, class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_JumpToSectionsEnd");
|
|
|
|
UAnimInstance_Montage_JumpToSectionsEnd_Params params;
|
|
params.SectionName = SectionName;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_JumpToSection
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName SectionName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::Montage_JumpToSection(const struct FName& SectionName, class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_JumpToSection");
|
|
|
|
UAnimInstance_Montage_JumpToSection_Params params;
|
|
params.SectionName = SectionName;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_IsPlaying
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::Montage_IsPlaying(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_IsPlaying");
|
|
|
|
UAnimInstance_Montage_IsPlaying_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_IsActive
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::Montage_IsActive(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_IsActive");
|
|
|
|
UAnimInstance_Montage_IsActive_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_GetPosition
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::Montage_GetPosition(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_GetPosition");
|
|
|
|
UAnimInstance_Montage_GetPosition_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_GetPlayRate
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::Montage_GetPlayRate(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_GetPlayRate");
|
|
|
|
UAnimInstance_Montage_GetPlayRate_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_GetIsStopped
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::Montage_GetIsStopped(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_GetIsStopped");
|
|
|
|
UAnimInstance_Montage_GetIsStopped_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_GetCurrentSection
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UAnimInstance::Montage_GetCurrentSection(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_GetCurrentSection");
|
|
|
|
UAnimInstance_Montage_GetCurrentSection_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.Montage_GetBlendTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::Montage_GetBlendTime(class UAnimMontage* Montage)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.Montage_GetBlendTime");
|
|
|
|
UAnimInstance_Montage_GetBlendTime_Params params;
|
|
params.Montage = Montage;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.LockAIResources
|
|
// (Final, BlueprintAuthorityOnly, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bLockMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool LockAILogic (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::LockAIResources(bool bLockMovement, bool LockAILogic)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.LockAIResources");
|
|
|
|
UAnimInstance_LockAIResources_Params params;
|
|
params.bLockMovement = bLockMovement;
|
|
params.LockAILogic = LockAILogic;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.IsSyncGroupBetweenMarkers
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSyncGroupName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PreviousMarker (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName NextMarker (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRespectMarkerOrder (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::IsSyncGroupBetweenMarkers(const struct FName& InSyncGroupName, const struct FName& PreviousMarker, const struct FName& NextMarker, bool bRespectMarkerOrder)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.IsSyncGroupBetweenMarkers");
|
|
|
|
UAnimInstance_IsSyncGroupBetweenMarkers_Params params;
|
|
params.InSyncGroupName = InSyncGroupName;
|
|
params.PreviousMarker = PreviousMarker;
|
|
params.NextMarker = NextMarker;
|
|
params.bRespectMarkerOrder = bRespectMarkerOrder;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.IsPlayingSlotAnimation
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimSequenceBase* Asset (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName SlotNodeName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::IsPlayingSlotAnimation(class UAnimSequenceBase* Asset, const struct FName& SlotNodeName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.IsPlayingSlotAnimation");
|
|
|
|
UAnimInstance_IsPlayingSlotAnimation_Params params;
|
|
params.Asset = Asset;
|
|
params.SlotNodeName = SlotNodeName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.IsAnyMontagePlaying
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::IsAnyMontagePlaying()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.IsAnyMontagePlaying");
|
|
|
|
UAnimInstance_IsAnyMontagePlaying_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.HasMarkerBeenHitThisFrame
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName SyncGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName MarkerName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::HasMarkerBeenHitThisFrame(const struct FName& SyncGroup, const struct FName& MarkerName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.HasMarkerBeenHitThisFrame");
|
|
|
|
UAnimInstance_HasMarkerBeenHitThisFrame_Params params;
|
|
params.SyncGroup = SyncGroup;
|
|
params.MarkerName = MarkerName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetTimeToClosestMarker
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName SyncGroup (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName MarkerName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutMarkerTime (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimInstance::GetTimeToClosestMarker(const struct FName& SyncGroup, const struct FName& MarkerName, float* OutMarkerTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetTimeToClosestMarker");
|
|
|
|
UAnimInstance_GetTimeToClosestMarker_Params params;
|
|
params.SyncGroup = SyncGroup;
|
|
params.MarkerName = MarkerName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutMarkerTime != nullptr)
|
|
*OutMarkerTime = params.OutMarkerTime;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetSyncGroupPosition
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSyncGroupName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FMarkerSyncAnimPosition ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FMarkerSyncAnimPosition UAnimInstance::GetSyncGroupPosition(const struct FName& InSyncGroupName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetSyncGroupPosition");
|
|
|
|
UAnimInstance_GetSyncGroupPosition_Params params;
|
|
params.InSyncGroupName = InSyncGroupName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetRelevantAnimTimeRemainingFraction
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StateIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetRelevantAnimTimeRemainingFraction(int MachineIndex, int StateIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetRelevantAnimTimeRemainingFraction");
|
|
|
|
UAnimInstance_GetRelevantAnimTimeRemainingFraction_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.StateIndex = StateIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetRelevantAnimTimeRemaining
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StateIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetRelevantAnimTimeRemaining(int MachineIndex, int StateIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetRelevantAnimTimeRemaining");
|
|
|
|
UAnimInstance_GetRelevantAnimTimeRemaining_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.StateIndex = StateIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetRelevantAnimTimeFraction
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StateIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetRelevantAnimTimeFraction(int MachineIndex, int StateIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetRelevantAnimTimeFraction");
|
|
|
|
UAnimInstance_GetRelevantAnimTimeFraction_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.StateIndex = StateIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetRelevantAnimTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StateIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetRelevantAnimTime(int MachineIndex, int StateIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetRelevantAnimTime");
|
|
|
|
UAnimInstance_GetRelevantAnimTime_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.StateIndex = StateIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetRelevantAnimLength
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StateIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetRelevantAnimLength(int MachineIndex, int StateIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetRelevantAnimLength");
|
|
|
|
UAnimInstance_GetRelevantAnimLength_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.StateIndex = StateIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetOwningComponent
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class USkeletalMeshComponent* UAnimInstance::GetOwningComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetOwningComponent");
|
|
|
|
UAnimInstance_GetOwningComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetOwningActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UAnimInstance::GetOwningActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetOwningActor");
|
|
|
|
UAnimInstance_GetOwningActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceTransitionTimeElapsedFraction
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TransitionIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceTransitionTimeElapsedFraction(int MachineIndex, int TransitionIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceTransitionTimeElapsedFraction");
|
|
|
|
UAnimInstance_GetInstanceTransitionTimeElapsedFraction_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.TransitionIndex = TransitionIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceTransitionTimeElapsed
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TransitionIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceTransitionTimeElapsed(int MachineIndex, int TransitionIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceTransitionTimeElapsed");
|
|
|
|
UAnimInstance_GetInstanceTransitionTimeElapsed_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.TransitionIndex = TransitionIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceTransitionCrossfadeDuration
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int TransitionIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceTransitionCrossfadeDuration(int MachineIndex, int TransitionIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceTransitionCrossfadeDuration");
|
|
|
|
UAnimInstance_GetInstanceTransitionCrossfadeDuration_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.TransitionIndex = TransitionIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceStateWeight
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StateIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceStateWeight(int MachineIndex, int StateIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceStateWeight");
|
|
|
|
UAnimInstance_GetInstanceStateWeight_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
params.StateIndex = StateIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceMachineWeight
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceMachineWeight(int MachineIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceMachineWeight");
|
|
|
|
UAnimInstance_GetInstanceMachineWeight_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceCurrentStateElapsedTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceCurrentStateElapsedTime(int MachineIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceCurrentStateElapsedTime");
|
|
|
|
UAnimInstance_GetInstanceCurrentStateElapsedTime_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceAssetPlayerTimeFromEndFraction
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int AssetPlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceAssetPlayerTimeFromEndFraction(int AssetPlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceAssetPlayerTimeFromEndFraction");
|
|
|
|
UAnimInstance_GetInstanceAssetPlayerTimeFromEndFraction_Params params;
|
|
params.AssetPlayerIndex = AssetPlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceAssetPlayerTimeFromEnd
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int AssetPlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceAssetPlayerTimeFromEnd(int AssetPlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceAssetPlayerTimeFromEnd");
|
|
|
|
UAnimInstance_GetInstanceAssetPlayerTimeFromEnd_Params params;
|
|
params.AssetPlayerIndex = AssetPlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceAssetPlayerTimeFraction
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int AssetPlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceAssetPlayerTimeFraction(int AssetPlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceAssetPlayerTimeFraction");
|
|
|
|
UAnimInstance_GetInstanceAssetPlayerTimeFraction_Params params;
|
|
params.AssetPlayerIndex = AssetPlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceAssetPlayerTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int AssetPlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceAssetPlayerTime(int AssetPlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceAssetPlayerTime");
|
|
|
|
UAnimInstance_GetInstanceAssetPlayerTime_Params params;
|
|
params.AssetPlayerIndex = AssetPlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetInstanceAssetPlayerLength
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int AssetPlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetInstanceAssetPlayerLength(int AssetPlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetInstanceAssetPlayerLength");
|
|
|
|
UAnimInstance_GetInstanceAssetPlayerLength_Params params;
|
|
params.AssetPlayerIndex = AssetPlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetCurveValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName CurveName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::GetCurveValue(const struct FName& CurveName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetCurveValue");
|
|
|
|
UAnimInstance_GetCurveValue_Params params;
|
|
params.CurveName = CurveName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetCurrentStateName
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int MachineIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UAnimInstance::GetCurrentStateName(int MachineIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetCurrentStateName");
|
|
|
|
UAnimInstance_GetCurrentStateName_Params params;
|
|
params.MachineIndex = MachineIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.GetCurrentActiveMontage
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimMontage* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAnimMontage* UAnimInstance::GetCurrentActiveMontage()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.GetCurrentActiveMontage");
|
|
|
|
UAnimInstance_GetCurrentActiveMontage_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.ClearMorphTargets
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAnimInstance::ClearMorphTargets()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.ClearMorphTargets");
|
|
|
|
UAnimInstance_ClearMorphTargets_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.CalculateDirection
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Velocity (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator BaseRotation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimInstance::CalculateDirection(const struct FVector& Velocity, const struct FRotator& BaseRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.CalculateDirection");
|
|
|
|
UAnimInstance_CalculateDirection_Params params;
|
|
params.Velocity = Velocity;
|
|
params.BaseRotation = BaseRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.BlueprintUpdateAnimation
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaTimeX (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimInstance::BlueprintUpdateAnimation(float DeltaTimeX)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.BlueprintUpdateAnimation");
|
|
|
|
UAnimInstance_BlueprintUpdateAnimation_Params params;
|
|
params.DeltaTimeX = DeltaTimeX;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.BlueprintPostEvaluateAnimation
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UAnimInstance::BlueprintPostEvaluateAnimation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.BlueprintPostEvaluateAnimation");
|
|
|
|
UAnimInstance_BlueprintPostEvaluateAnimation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.BlueprintInitializeAnimation
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UAnimInstance::BlueprintInitializeAnimation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.BlueprintInitializeAnimation");
|
|
|
|
UAnimInstance_BlueprintInitializeAnimation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimInstance.BlueprintBeginPlay
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UAnimInstance::BlueprintBeginPlay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimInstance.BlueprintBeginPlay");
|
|
|
|
UAnimInstance_BlueprintBeginPlay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameInstance.ReceiveShutdown
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UGameInstance::ReceiveShutdown()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameInstance.ReceiveShutdown");
|
|
|
|
UGameInstance_ReceiveShutdown_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameInstance.ReceiveInit
|
|
// (Event, Public, BlueprintEvent)
|
|
|
|
void UGameInstance::ReceiveInit()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameInstance.ReceiveInit");
|
|
|
|
UGameInstance_ReceiveInit_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameInstance.HandleTravelError
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<ETravelFailure> FailureType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameInstance::HandleTravelError(TEnumAsByte<ETravelFailure> FailureType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameInstance.HandleTravelError");
|
|
|
|
UGameInstance_HandleTravelError_Params params;
|
|
params.FailureType = FailureType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameInstance.HandleNetworkError
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// TEnumAsByte<ENetworkFailure> FailureType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsServer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameInstance::HandleNetworkError(TEnumAsByte<ENetworkFailure> FailureType, bool bIsServer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameInstance.HandleNetworkError");
|
|
|
|
UGameInstance_HandleNetworkError_Params params;
|
|
params.FailureType = FailureType;
|
|
params.bIsServer = bIsServer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameInstance.DebugRemovePlayer
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// int ControllerId (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameInstance::DebugRemovePlayer(int ControllerId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameInstance.DebugRemovePlayer");
|
|
|
|
UGameInstance_DebugRemovePlayer_Params params;
|
|
params.ControllerId = ControllerId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameInstance.DebugCreatePlayer
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// int ControllerId (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameInstance::DebugCreatePlayer(int ControllerId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameInstance.DebugCreatePlayer");
|
|
|
|
UGameInstance_DebugCreatePlayer_Params params;
|
|
params.ControllerId = ControllerId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.UnloadStreamLevel
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName LevelName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UGameplayStatics::UnloadStreamLevel(class UObject* WorldContextObject, const struct FName& LevelName, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.UnloadStreamLevel");
|
|
|
|
UGameplayStatics_UnloadStreamLevel_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.LevelName = LevelName;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SuggestProjectileVelocity_CustomArc
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector OutLaunchVelocity (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector startPos (Parm, IsPlainOldData)
|
|
// struct FVector EndPos (Parm, IsPlainOldData)
|
|
// float OverrideGravityZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ArcParam (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::SuggestProjectileVelocity_CustomArc(class UObject* WorldContextObject, const struct FVector& startPos, const struct FVector& EndPos, float OverrideGravityZ, float ArcParam, struct FVector* OutLaunchVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SuggestProjectileVelocity_CustomArc");
|
|
|
|
UGameplayStatics_SuggestProjectileVelocity_CustomArc_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.startPos = startPos;
|
|
params.EndPos = EndPos;
|
|
params.OverrideGravityZ = OverrideGravityZ;
|
|
params.ArcParam = ArcParam;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutLaunchVelocity != nullptr)
|
|
*OutLaunchVelocity = params.OutLaunchVelocity;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnSoundAttached
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bStopWhenAttachedToDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundConcurrency* ConcurrencySettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::SpawnSoundAttached(class USoundBase* Sound, class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, TEnumAsByte<EAttachLocation> LocationType, bool bStopWhenAttachedToDestroyed, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnSoundAttached");
|
|
|
|
UGameplayStatics_SpawnSoundAttached_Params params;
|
|
params.Sound = Sound;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.AttachPointName = AttachPointName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.LocationType = LocationType;
|
|
params.bStopWhenAttachedToDestroyed = bStopWhenAttachedToDestroyed;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.ConcurrencySettings = ConcurrencySettings;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnSoundAtLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundConcurrency* ConcurrencySettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::SpawnSoundAtLocation(class UObject* WorldContextObject, class USoundBase* Sound, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnSoundAtLocation");
|
|
|
|
UGameplayStatics_SpawnSoundAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Sound = Sound;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.ConcurrencySettings = ConcurrencySettings;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnSound2D
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundConcurrency* ConcurrencySettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPersistAcrossLevelTransition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::SpawnSound2D(class UObject* WorldContextObject, class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundConcurrency* ConcurrencySettings, bool bPersistAcrossLevelTransition, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnSound2D");
|
|
|
|
UGameplayStatics_SpawnSound2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Sound = Sound;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.ConcurrencySettings = ConcurrencySettings;
|
|
params.bPersistAcrossLevelTransition = bPersistAcrossLevelTransition;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnObject
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* ObjectClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* Outer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UObject* UGameplayStatics::SpawnObject(class UClass* ObjectClass, class UObject* Outer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnObject");
|
|
|
|
UGameplayStatics_SpawnObject_Params params;
|
|
params.ObjectClass = ObjectClass;
|
|
params.Outer = Outer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnForceFeedbackAttached
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UForceFeedbackEffect* ForceFeedbackEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bStopWhenAttachedToDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float IntensityMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UForceFeedbackAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UForceFeedbackComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UForceFeedbackComponent* UGameplayStatics::SpawnForceFeedbackAttached(class UForceFeedbackEffect* ForceFeedbackEffect, class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, TEnumAsByte<EAttachLocation> LocationType, bool bStopWhenAttachedToDestroyed, bool bLooping, float IntensityMultiplier, float StartTime, class UForceFeedbackAttenuation* AttenuationSettings, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnForceFeedbackAttached");
|
|
|
|
UGameplayStatics_SpawnForceFeedbackAttached_Params params;
|
|
params.ForceFeedbackEffect = ForceFeedbackEffect;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.AttachPointName = AttachPointName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.LocationType = LocationType;
|
|
params.bStopWhenAttachedToDestroyed = bStopWhenAttachedToDestroyed;
|
|
params.bLooping = bLooping;
|
|
params.IntensityMultiplier = IntensityMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnForceFeedbackAtLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UForceFeedbackEffect* ForceFeedbackEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float IntensityMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UForceFeedbackAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UForceFeedbackComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UForceFeedbackComponent* UGameplayStatics::SpawnForceFeedbackAtLocation(class UObject* WorldContextObject, class UForceFeedbackEffect* ForceFeedbackEffect, const struct FVector& Location, const struct FRotator& Rotation, bool bLooping, float IntensityMultiplier, float StartTime, class UForceFeedbackAttenuation* AttenuationSettings, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnForceFeedbackAtLocation");
|
|
|
|
UGameplayStatics_SpawnForceFeedbackAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ForceFeedbackEffect = ForceFeedbackEffect;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.bLooping = bLooping;
|
|
params.IntensityMultiplier = IntensityMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnEmitterAttached
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UParticleSystem* EmitterTemplate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// struct FVector Scale (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UParticleSystemComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UParticleSystemComponent* UGameplayStatics::SpawnEmitterAttached(class UParticleSystem* EmitterTemplate, class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, const struct FVector& Scale, TEnumAsByte<EAttachLocation> LocationType, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnEmitterAttached");
|
|
|
|
UGameplayStatics_SpawnEmitterAttached_Params params;
|
|
params.EmitterTemplate = EmitterTemplate;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.AttachPointName = AttachPointName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.Scale = Scale;
|
|
params.LocationType = LocationType;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnEmitterAtLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UParticleSystem* EmitterTemplate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// struct FVector Scale (Parm, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UParticleSystemComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UParticleSystemComponent* UGameplayStatics::SpawnEmitterAtLocation(class UObject* WorldContextObject, class UParticleSystem* EmitterTemplate, const struct FVector& Location, const struct FRotator& Rotation, const struct FVector& Scale, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnEmitterAtLocation");
|
|
|
|
UGameplayStatics_SpawnEmitterAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.EmitterTemplate = EmitterTemplate;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.Scale = Scale;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnDialogueAttached
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UDialogueWave* Dialogue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDialogueContext Context (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bStopWhenAttachedToDestroyed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::SpawnDialogueAttached(class UDialogueWave* Dialogue, const struct FDialogueContext& Context, class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, TEnumAsByte<EAttachLocation> LocationType, bool bStopWhenAttachedToDestroyed, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnDialogueAttached");
|
|
|
|
UGameplayStatics_SpawnDialogueAttached_Params params;
|
|
params.Dialogue = Dialogue;
|
|
params.Context = Context;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.AttachPointName = AttachPointName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.LocationType = LocationType;
|
|
params.bStopWhenAttachedToDestroyed = bStopWhenAttachedToDestroyed;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnDialogueAtLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDialogueWave* Dialogue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDialogueContext Context (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::SpawnDialogueAtLocation(class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnDialogueAtLocation");
|
|
|
|
UGameplayStatics_SpawnDialogueAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Dialogue = Dialogue;
|
|
params.Context = Context;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnDialogue2D
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDialogueWave* Dialogue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDialogueContext Context (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::SpawnDialogue2D(class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, float VolumeMultiplier, float PitchMultiplier, float StartTime, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnDialogue2D");
|
|
|
|
UGameplayStatics_SpawnDialogue2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Dialogue = Dialogue;
|
|
params.Context = Context;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnDecalAttached
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* DecalMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector DecalSize (Parm, IsPlainOldData)
|
|
// class USceneComponent* AttachToComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName AttachPointName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EAttachLocation> LocationType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LifeSpan (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDecalComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UDecalComponent* UGameplayStatics::SpawnDecalAttached(class UMaterialInterface* DecalMaterial, const struct FVector& DecalSize, class USceneComponent* AttachToComponent, const struct FName& AttachPointName, const struct FVector& Location, const struct FRotator& Rotation, TEnumAsByte<EAttachLocation> LocationType, float LifeSpan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnDecalAttached");
|
|
|
|
UGameplayStatics_SpawnDecalAttached_Params params;
|
|
params.DecalMaterial = DecalMaterial;
|
|
params.DecalSize = DecalSize;
|
|
params.AttachToComponent = AttachToComponent;
|
|
params.AttachPointName = AttachPointName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.LocationType = LocationType;
|
|
params.LifeSpan = LifeSpan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SpawnDecalAtLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* DecalMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector DecalSize (Parm, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// float LifeSpan (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDecalComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UDecalComponent* UGameplayStatics::SpawnDecalAtLocation(class UObject* WorldContextObject, class UMaterialInterface* DecalMaterial, const struct FVector& DecalSize, const struct FVector& Location, const struct FRotator& Rotation, float LifeSpan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SpawnDecalAtLocation");
|
|
|
|
UGameplayStatics_SpawnDecalAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.DecalMaterial = DecalMaterial;
|
|
params.DecalSize = DecalSize;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.LifeSpan = LifeSpan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetWorldOriginLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FIntVector NewLocation (Parm, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetWorldOriginLocation(class UObject* WorldContextObject, const struct FIntVector& NewLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetWorldOriginLocation");
|
|
|
|
UGameplayStatics_SetWorldOriginLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.NewLocation = NewLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetSubtitlesEnabled
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetSubtitlesEnabled(bool bEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetSubtitlesEnabled");
|
|
|
|
UGameplayStatics_SetSubtitlesEnabled_Params params;
|
|
params.bEnabled = bEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetSoundMixClassOverride
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundMix* InSoundMixModifier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundClass* InSoundClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Volume (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Pitch (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeInTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bApplyToChildren (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetSoundMixClassOverride(class UObject* WorldContextObject, class USoundMix* InSoundMixModifier, class USoundClass* InSoundClass, float Volume, float Pitch, float FadeInTime, bool bApplyToChildren)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetSoundMixClassOverride");
|
|
|
|
UGameplayStatics_SetSoundMixClassOverride_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InSoundMixModifier = InSoundMixModifier;
|
|
params.InSoundClass = InSoundClass;
|
|
params.Volume = Volume;
|
|
params.Pitch = Pitch;
|
|
params.FadeInTime = FadeInTime;
|
|
params.bApplyToChildren = bApplyToChildren;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetPlayerControllerID
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ControllerId (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetPlayerControllerID(class APlayerController* Player, int ControllerId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetPlayerControllerID");
|
|
|
|
UGameplayStatics_SetPlayerControllerID_Params params;
|
|
params.Player = Player;
|
|
params.ControllerId = ControllerId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetGlobalTimeDilation
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TimeDilation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetGlobalTimeDilation(class UObject* WorldContextObject, float TimeDilation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetGlobalTimeDilation");
|
|
|
|
UGameplayStatics_SetGlobalTimeDilation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TimeDilation = TimeDilation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetGlobalPitchModulation
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchModulation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TimeSec (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetGlobalPitchModulation(class UObject* WorldContextObject, float PitchModulation, float TimeSec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetGlobalPitchModulation");
|
|
|
|
UGameplayStatics_SetGlobalPitchModulation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PitchModulation = PitchModulation;
|
|
params.TimeSec = TimeSec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetGlobalListenerFocusParameters
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FocusAzimuthScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NonFocusAzimuthScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FocusDistanceScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NonFocusDistanceScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FocusVolumeScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NonFocusVolumeScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FocusPriorityScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float NonFocusPriorityScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetGlobalListenerFocusParameters(class UObject* WorldContextObject, float FocusAzimuthScale, float NonFocusAzimuthScale, float FocusDistanceScale, float NonFocusDistanceScale, float FocusVolumeScale, float NonFocusVolumeScale, float FocusPriorityScale, float NonFocusPriorityScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetGlobalListenerFocusParameters");
|
|
|
|
UGameplayStatics_SetGlobalListenerFocusParameters_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.FocusAzimuthScale = FocusAzimuthScale;
|
|
params.NonFocusAzimuthScale = NonFocusAzimuthScale;
|
|
params.FocusDistanceScale = FocusDistanceScale;
|
|
params.NonFocusDistanceScale = NonFocusDistanceScale;
|
|
params.FocusVolumeScale = FocusVolumeScale;
|
|
params.NonFocusVolumeScale = NonFocusVolumeScale;
|
|
params.FocusPriorityScale = FocusPriorityScale;
|
|
params.NonFocusPriorityScale = NonFocusPriorityScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetGamePaused
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPaused (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::SetGamePaused(class UObject* WorldContextObject, bool bPaused)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetGamePaused");
|
|
|
|
UGameplayStatics_SetGamePaused_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.bPaused = bPaused;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SetBaseSoundMix
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundMix* InSoundMix (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::SetBaseSoundMix(class UObject* WorldContextObject, class USoundMix* InSoundMix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SetBaseSoundMix");
|
|
|
|
UGameplayStatics_SetBaseSoundMix_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InSoundMix = InSoundMix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.SaveGameToSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USaveGame* SaveGameObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString SlotName (Parm, ZeroConstructor)
|
|
// int UserIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::SaveGameToSlot(class USaveGame* SaveGameObject, const struct FString& SlotName, int UserIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.SaveGameToSlot");
|
|
|
|
UGameplayStatics_SaveGameToSlot_Params params;
|
|
params.SaveGameObject = SaveGameObject;
|
|
params.SlotName = SlotName;
|
|
params.UserIndex = UserIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.RemovePlayer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDestroyPawn (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::RemovePlayer(class APlayerController* Player, bool bDestroyPawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.RemovePlayer");
|
|
|
|
UGameplayStatics_RemovePlayer_Params params;
|
|
params.Player = Player;
|
|
params.bDestroyPawn = bDestroyPawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.RebaseZeroOriginOntoLocal
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector WorldLocation (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UGameplayStatics::RebaseZeroOriginOntoLocal(class UObject* WorldContextObject, const struct FVector& WorldLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.RebaseZeroOriginOntoLocal");
|
|
|
|
UGameplayStatics_RebaseZeroOriginOntoLocal_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.WorldLocation = WorldLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.RebaseLocalOriginOntoZero
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector WorldLocation (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UGameplayStatics::RebaseLocalOriginOntoZero(class UObject* WorldContextObject, const struct FVector& WorldLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.RebaseLocalOriginOntoZero");
|
|
|
|
UGameplayStatics_RebaseLocalOriginOntoZero_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.WorldLocation = WorldLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PushSoundMixModifier
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundMix* InSoundMixModifier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PushSoundMixModifier(class UObject* WorldContextObject, class USoundMix* InSoundMixModifier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PushSoundMixModifier");
|
|
|
|
UGameplayStatics_PushSoundMixModifier_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InSoundMixModifier = InSoundMixModifier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ProjectWorldToScreen
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector WorldPosition (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, OutParm, IsPlainOldData)
|
|
// bool bPlayerViewportRelative (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::ProjectWorldToScreen(class APlayerController* Player, const struct FVector& WorldPosition, bool bPlayerViewportRelative, struct FVector2D* ScreenPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ProjectWorldToScreen");
|
|
|
|
UGameplayStatics_ProjectWorldToScreen_Params params;
|
|
params.Player = Player;
|
|
params.WorldPosition = WorldPosition;
|
|
params.bPlayerViewportRelative = bPlayerViewportRelative;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ScreenPosition != nullptr)
|
|
*ScreenPosition = params.ScreenPosition;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PopSoundMixModifier
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundMix* InSoundMixModifier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PopSoundMixModifier(class UObject* WorldContextObject, class USoundMix* InSoundMixModifier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PopSoundMixModifier");
|
|
|
|
UGameplayStatics_PopSoundMixModifier_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InSoundMixModifier = InSoundMixModifier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PlayWorldCameraShake
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* Shake (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Epicenter (Parm, IsPlainOldData)
|
|
// float InnerRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OuterRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Falloff (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bOrientShakeTowardsEpicenter (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PlayWorldCameraShake(class UObject* WorldContextObject, class UClass* Shake, const struct FVector& Epicenter, float InnerRadius, float OuterRadius, float Falloff, bool bOrientShakeTowardsEpicenter)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PlayWorldCameraShake");
|
|
|
|
UGameplayStatics_PlayWorldCameraShake_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Shake = Shake;
|
|
params.Epicenter = Epicenter;
|
|
params.InnerRadius = InnerRadius;
|
|
params.OuterRadius = OuterRadius;
|
|
params.Falloff = Falloff;
|
|
params.bOrientShakeTowardsEpicenter = bOrientShakeTowardsEpicenter;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PlaySoundAtLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundConcurrency* ConcurrencySettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* OwningActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PlaySoundAtLocation(class UObject* WorldContextObject, class USoundBase* Sound, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings, class USoundConcurrency* ConcurrencySettings, class AActor* OwningActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PlaySoundAtLocation");
|
|
|
|
UGameplayStatics_PlaySoundAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Sound = Sound;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
params.ConcurrencySettings = ConcurrencySettings;
|
|
params.OwningActor = OwningActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PlaySound2D
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundConcurrency* ConcurrencySettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* OwningActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PlaySound2D(class UObject* WorldContextObject, class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundConcurrency* ConcurrencySettings, class AActor* OwningActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PlaySound2D");
|
|
|
|
UGameplayStatics_PlaySound2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Sound = Sound;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.ConcurrencySettings = ConcurrencySettings;
|
|
params.OwningActor = OwningActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PlayDialogueAtLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDialogueWave* Dialogue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDialogueContext Context (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundAttenuation* AttenuationSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PlayDialogueAtLocation(class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, const struct FVector& Location, const struct FRotator& Rotation, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundAttenuation* AttenuationSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PlayDialogueAtLocation");
|
|
|
|
UGameplayStatics_PlayDialogueAtLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Dialogue = Dialogue;
|
|
params.Context = Context;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.AttenuationSettings = AttenuationSettings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.PlayDialogue2D
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UDialogueWave* Dialogue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDialogueContext Context (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::PlayDialogue2D(class UObject* WorldContextObject, class UDialogueWave* Dialogue, const struct FDialogueContext& Context, float VolumeMultiplier, float PitchMultiplier, float StartTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.PlayDialogue2D");
|
|
|
|
UGameplayStatics_PlayDialogue2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Dialogue = Dialogue;
|
|
params.Context = Context;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ParseOption
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString Options (Parm, ZeroConstructor)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UGameplayStatics::ParseOption(const struct FString& Options, const struct FString& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ParseOption");
|
|
|
|
UGameplayStatics_ParseOption_Params params;
|
|
params.Options = Options;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.OpenLevel
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName LevelName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAbsolute (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Options (Parm, ZeroConstructor)
|
|
|
|
void UGameplayStatics::OpenLevel(class UObject* WorldContextObject, const struct FName& LevelName, bool bAbsolute, const struct FString& Options)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.OpenLevel");
|
|
|
|
UGameplayStatics_OpenLevel_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.LevelName = LevelName;
|
|
params.bAbsolute = bAbsolute;
|
|
params.Options = Options;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.MakeHitResult
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool bBlockingHit (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bInitialOverlap (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FVector ImpactPoint (Parm, IsPlainOldData)
|
|
// struct FVector Normal (Parm, IsPlainOldData)
|
|
// struct FVector ImpactNormal (Parm, IsPlainOldData)
|
|
// class UPhysicalMaterial* PhysMat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* HitActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* HitComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName HitBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int HitItem (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int FaceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector TraceStart (Parm, IsPlainOldData)
|
|
// struct FVector TraceEnd (Parm, IsPlainOldData)
|
|
// struct FHitResult ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FHitResult UGameplayStatics::MakeHitResult(bool bBlockingHit, bool bInitialOverlap, float Time, float Distance, const struct FVector& Location, const struct FVector& ImpactPoint, const struct FVector& Normal, const struct FVector& ImpactNormal, class UPhysicalMaterial* PhysMat, class AActor* HitActor, class UPrimitiveComponent* HitComponent, const struct FName& HitBoneName, int HitItem, int FaceIndex, const struct FVector& TraceStart, const struct FVector& TraceEnd)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.MakeHitResult");
|
|
|
|
UGameplayStatics_MakeHitResult_Params params;
|
|
params.bBlockingHit = bBlockingHit;
|
|
params.bInitialOverlap = bInitialOverlap;
|
|
params.Time = Time;
|
|
params.Distance = Distance;
|
|
params.Location = Location;
|
|
params.ImpactPoint = ImpactPoint;
|
|
params.Normal = Normal;
|
|
params.ImpactNormal = ImpactNormal;
|
|
params.PhysMat = PhysMat;
|
|
params.HitActor = HitActor;
|
|
params.HitComponent = HitComponent;
|
|
params.HitBoneName = HitBoneName;
|
|
params.HitItem = HitItem;
|
|
params.FaceIndex = FaceIndex;
|
|
params.TraceStart = TraceStart;
|
|
params.TraceEnd = TraceEnd;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.LoadStreamLevel
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName LevelName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bMakeVisibleAfterLoad (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShouldBlockOnLoad (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UGameplayStatics::LoadStreamLevel(class UObject* WorldContextObject, const struct FName& LevelName, bool bMakeVisibleAfterLoad, bool bShouldBlockOnLoad, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.LoadStreamLevel");
|
|
|
|
UGameplayStatics_LoadStreamLevel_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.LevelName = LevelName;
|
|
params.bMakeVisibleAfterLoad = bMakeVisibleAfterLoad;
|
|
params.bShouldBlockOnLoad = bShouldBlockOnLoad;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.LoadGameFromSlotWithSizeLimit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString SlotName (Parm, ZeroConstructor)
|
|
// int UserIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaxSerSize (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USaveGame* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USaveGame* UGameplayStatics::LoadGameFromSlotWithSizeLimit(const struct FString& SlotName, int UserIndex, int MaxSerSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.LoadGameFromSlotWithSizeLimit");
|
|
|
|
UGameplayStatics_LoadGameFromSlotWithSizeLimit_Params params;
|
|
params.SlotName = SlotName;
|
|
params.UserIndex = UserIndex;
|
|
params.MaxSerSize = MaxSerSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.LoadGameFromSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString SlotName (Parm, ZeroConstructor)
|
|
// int UserIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USaveGame* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USaveGame* UGameplayStatics::LoadGameFromSlot(const struct FString& SlotName, int UserIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.LoadGameFromSlot");
|
|
|
|
UGameplayStatics_LoadGameFromSlot_Params params;
|
|
params.SlotName = SlotName;
|
|
params.UserIndex = UserIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.IsGamePaused
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::IsGamePaused(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.IsGamePaused");
|
|
|
|
UGameplayStatics_IsGamePaused_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.HasOption
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString Options (Parm, ZeroConstructor)
|
|
// struct FString InKey (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::HasOption(const struct FString& Options, const struct FString& InKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.HasOption");
|
|
|
|
UGameplayStatics_HasOption_Params params;
|
|
params.Options = Options;
|
|
params.InKey = InKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.HasLaunchOption
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString OptionToCheck (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::HasLaunchOption(const struct FString& OptionToCheck)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.HasLaunchOption");
|
|
|
|
UGameplayStatics_HasLaunchOption_Params params;
|
|
params.OptionToCheck = OptionToCheck;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GrassOverlappingSphereCount
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UStaticMesh* StaticMesh (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector CenterPosition (Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameplayStatics::GrassOverlappingSphereCount(class UObject* WorldContextObject, class UStaticMesh* StaticMesh, const struct FVector& CenterPosition, float Radius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GrassOverlappingSphereCount");
|
|
|
|
UGameplayStatics_GrassOverlappingSphereCount_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.StaticMesh = StaticMesh;
|
|
params.CenterPosition = CenterPosition;
|
|
params.Radius = Radius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetWorldOriginLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FIntVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntVector UGameplayStatics::GetWorldOriginLocation(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetWorldOriginLocation");
|
|
|
|
UGameplayStatics_GetWorldOriginLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetWorldDeltaSeconds
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::GetWorldDeltaSeconds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetWorldDeltaSeconds");
|
|
|
|
UGameplayStatics_GetWorldDeltaSeconds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetUnpausedTimeSeconds
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::GetUnpausedTimeSeconds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetUnpausedTimeSeconds");
|
|
|
|
UGameplayStatics_GetUnpausedTimeSeconds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetTimeSeconds
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::GetTimeSeconds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetTimeSeconds");
|
|
|
|
UGameplayStatics_GetTimeSeconds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetSurfaceType
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<EPhysicalSurface> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EPhysicalSurface> UGameplayStatics::GetSurfaceType(const struct FHitResult& Hit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetSurfaceType");
|
|
|
|
UGameplayStatics_GetSurfaceType_Params params;
|
|
params.Hit = Hit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetStreamingLevel
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PackageName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ULevelStreaming* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULevelStreaming* UGameplayStatics::GetStreamingLevel(class UObject* WorldContextObject, const struct FName& PackageName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetStreamingLevel");
|
|
|
|
UGameplayStatics_GetStreamingLevel_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PackageName = PackageName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetRealTimeSeconds
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::GetRealTimeSeconds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetRealTimeSeconds");
|
|
|
|
UGameplayStatics_GetRealTimeSeconds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetPlayerPawn
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int PlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APawn* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APawn* UGameplayStatics::GetPlayerPawn(class UObject* WorldContextObject, int PlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetPlayerPawn");
|
|
|
|
UGameplayStatics_GetPlayerPawn_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerIndex = PlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetPlayerControllerID
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameplayStatics::GetPlayerControllerID(class APlayerController* Player)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetPlayerControllerID");
|
|
|
|
UGameplayStatics_GetPlayerControllerID_Params params;
|
|
params.Player = Player;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetPlayerController
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int PlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* UGameplayStatics::GetPlayerController(class UObject* WorldContextObject, int PlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetPlayerController");
|
|
|
|
UGameplayStatics_GetPlayerController_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerIndex = PlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetPlayerCharacter
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int PlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ACharacter* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ACharacter* UGameplayStatics::GetPlayerCharacter(class UObject* WorldContextObject, int PlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetPlayerCharacter");
|
|
|
|
UGameplayStatics_GetPlayerCharacter_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerIndex = PlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetPlayerCameraManager
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int PlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerCameraManager* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerCameraManager* UGameplayStatics::GetPlayerCameraManager(class UObject* WorldContextObject, int PlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetPlayerCameraManager");
|
|
|
|
UGameplayStatics_GetPlayerCameraManager_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlayerIndex = PlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetPlatformName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UGameplayStatics::GetPlatformName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetPlatformName");
|
|
|
|
UGameplayStatics_GetPlatformName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetObjectClass
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UClass* UGameplayStatics::GetObjectClass(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetObjectClass");
|
|
|
|
UGameplayStatics_GetObjectClass_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetKeyValue
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString Pair (Parm, ZeroConstructor)
|
|
// struct FString Key (Parm, OutParm, ZeroConstructor)
|
|
// struct FString Value (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UGameplayStatics::GetKeyValue(const struct FString& Pair, struct FString* Key, struct FString* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetKeyValue");
|
|
|
|
UGameplayStatics_GetKeyValue_Params params;
|
|
params.Pair = Pair;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Key != nullptr)
|
|
*Key = params.Key;
|
|
if (Value != nullptr)
|
|
*Value = params.Value;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetIntOption
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString Options (Parm, ZeroConstructor)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// int DefaultValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameplayStatics::GetIntOption(const struct FString& Options, const struct FString& Key, int DefaultValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetIntOption");
|
|
|
|
UGameplayStatics_GetIntOption_Params params;
|
|
params.Options = Options;
|
|
params.Key = Key;
|
|
params.DefaultValue = DefaultValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetGlobalTimeDilation
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::GetGlobalTimeDilation(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetGlobalTimeDilation");
|
|
|
|
UGameplayStatics_GetGlobalTimeDilation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetGameState
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AGameStateBase* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AGameStateBase* UGameplayStatics::GetGameState(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetGameState");
|
|
|
|
UGameplayStatics_GetGameState_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetGameMode
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AGameModeBase* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AGameModeBase* UGameplayStatics::GetGameMode(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetGameMode");
|
|
|
|
UGameplayStatics_GetGameMode_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetGameInstance
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UGameInstance* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UGameInstance* UGameplayStatics::GetGameInstance(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetGameInstance");
|
|
|
|
UGameplayStatics_GetGameInstance_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetCurrentReverbEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UReverbEffect* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UReverbEffect* UGameplayStatics::GetCurrentReverbEffect(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetCurrentReverbEffect");
|
|
|
|
UGameplayStatics_GetCurrentReverbEffect_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetCurrentLevelName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRemovePrefixString (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UGameplayStatics::GetCurrentLevelName(class UObject* WorldContextObject, bool bRemovePrefixString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetCurrentLevelName");
|
|
|
|
UGameplayStatics_GetCurrentLevelName_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.bRemovePrefixString = bRemovePrefixString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetAudioTimeSeconds
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::GetAudioTimeSeconds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetAudioTimeSeconds");
|
|
|
|
UGameplayStatics_GetAudioTimeSeconds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetAllActorsWithTag
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName Tag (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UGameplayStatics::GetAllActorsWithTag(class UObject* WorldContextObject, const struct FName& Tag, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetAllActorsWithTag");
|
|
|
|
UGameplayStatics_GetAllActorsWithTag_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Tag = Tag;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetAllActorsWithInterface
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* Interface (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UGameplayStatics::GetAllActorsWithInterface(class UObject* WorldContextObject, class UClass* Interface, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetAllActorsWithInterface");
|
|
|
|
UGameplayStatics_GetAllActorsWithInterface_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Interface = Interface;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetAllActorsOfClass
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ActorClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UGameplayStatics::GetAllActorsOfClass(class UObject* WorldContextObject, class UClass* ActorClass, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetAllActorsOfClass");
|
|
|
|
UGameplayStatics_GetAllActorsOfClass_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ActorClass = ActorClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetActorArrayBounds
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class AActor*> Actors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bOnlyCollidingComponents (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Center (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UGameplayStatics::GetActorArrayBounds(TArray<class AActor*> Actors, bool bOnlyCollidingComponents, struct FVector* Center, struct FVector* BoxExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetActorArrayBounds");
|
|
|
|
UGameplayStatics_GetActorArrayBounds_Params params;
|
|
params.Actors = Actors;
|
|
params.bOnlyCollidingComponents = bOnlyCollidingComponents;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Center != nullptr)
|
|
*Center = params.Center;
|
|
if (BoxExtent != nullptr)
|
|
*BoxExtent = params.BoxExtent;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetActorArrayAverageLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class AActor*> Actors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UGameplayStatics::GetActorArrayAverageLocation(TArray<class AActor*> Actors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetActorArrayAverageLocation");
|
|
|
|
UGameplayStatics_GetActorArrayAverageLocation_Params params;
|
|
params.Actors = Actors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.GetAccurateRealTime
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Seconds (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float PartialSeconds (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::GetAccurateRealTime(class UObject* WorldContextObject, int* Seconds, float* PartialSeconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.GetAccurateRealTime");
|
|
|
|
UGameplayStatics_GetAccurateRealTime_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Seconds != nullptr)
|
|
*Seconds = params.Seconds;
|
|
if (PartialSeconds != nullptr)
|
|
*PartialSeconds = params.PartialSeconds;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.FlushLevelStreaming
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::FlushLevelStreaming(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.FlushLevelStreaming");
|
|
|
|
UGameplayStatics_FlushLevelStreaming_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.FinishSpawningActor
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Actor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform SpawnTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UGameplayStatics::FinishSpawningActor(class AActor* Actor, const struct FTransform& SpawnTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.FinishSpawningActor");
|
|
|
|
UGameplayStatics_FinishSpawningActor_Params params;
|
|
params.Actor = Actor;
|
|
params.SpawnTransform = SpawnTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.FindCollisionUV
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// int UVChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D UV (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::FindCollisionUV(const struct FHitResult& Hit, int UVChannel, struct FVector2D* UV)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.FindCollisionUV");
|
|
|
|
UGameplayStatics_FindCollisionUV_Params params;
|
|
params.Hit = Hit;
|
|
params.UVChannel = UVChannel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (UV != nullptr)
|
|
*UV = params.UV;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.EnableLiveStreaming
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool Enable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::EnableLiveStreaming(bool Enable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.EnableLiveStreaming");
|
|
|
|
UGameplayStatics_EnableLiveStreaming_Params params;
|
|
params.Enable = Enable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.DoesSaveGameExist
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString SlotName (Parm, ZeroConstructor)
|
|
// int UserIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::DoesSaveGameExist(const struct FString& SlotName, int UserIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.DoesSaveGameExist");
|
|
|
|
UGameplayStatics_DoesSaveGameExist_Params params;
|
|
params.SlotName = SlotName;
|
|
params.UserIndex = UserIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.DeprojectScreenToWorld
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class APlayerController* Player (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector WorldPosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector WorldDirection (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::DeprojectScreenToWorld(class APlayerController* Player, const struct FVector2D& ScreenPosition, struct FVector* WorldPosition, struct FVector* WorldDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.DeprojectScreenToWorld");
|
|
|
|
UGameplayStatics_DeprojectScreenToWorld_Params params;
|
|
params.Player = Player;
|
|
params.ScreenPosition = ScreenPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (WorldPosition != nullptr)
|
|
*WorldPosition = params.WorldPosition;
|
|
if (WorldDirection != nullptr)
|
|
*WorldDirection = params.WorldDirection;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.DeleteGameInSlot
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString SlotName (Parm, ZeroConstructor)
|
|
// int UserIndex (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::DeleteGameInSlot(const struct FString& SlotName, int UserIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.DeleteGameInSlot");
|
|
|
|
UGameplayStatics_DeleteGameInSlot_Params params;
|
|
params.SlotName = SlotName;
|
|
params.UserIndex = UserIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.DeactivateReverbEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName TagName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::DeactivateReverbEffect(class UObject* WorldContextObject, const struct FName& TagName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.DeactivateReverbEffect");
|
|
|
|
UGameplayStatics_DeactivateReverbEffect_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TagName = TagName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.CreateSound2D
|
|
// (Final, BlueprintCosmetic, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundBase* Sound (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundConcurrency* ConcurrencySettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPersistAcrossLevelTransition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAutoDestroy (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UAudioComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UAudioComponent* UGameplayStatics::CreateSound2D(class UObject* WorldContextObject, class USoundBase* Sound, float VolumeMultiplier, float PitchMultiplier, float StartTime, class USoundConcurrency* ConcurrencySettings, bool bPersistAcrossLevelTransition, bool bAutoDestroy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.CreateSound2D");
|
|
|
|
UGameplayStatics_CreateSound2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Sound = Sound;
|
|
params.VolumeMultiplier = VolumeMultiplier;
|
|
params.PitchMultiplier = PitchMultiplier;
|
|
params.StartTime = StartTime;
|
|
params.ConcurrencySettings = ConcurrencySettings;
|
|
params.bPersistAcrossLevelTransition = bPersistAcrossLevelTransition;
|
|
params.bAutoDestroy = bAutoDestroy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.CreateSaveGameObjectFromBlueprint
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UBlueprint* SaveGameBlueprint (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USaveGame* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USaveGame* UGameplayStatics::CreateSaveGameObjectFromBlueprint(class UBlueprint* SaveGameBlueprint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.CreateSaveGameObjectFromBlueprint");
|
|
|
|
UGameplayStatics_CreateSaveGameObjectFromBlueprint_Params params;
|
|
params.SaveGameBlueprint = SaveGameBlueprint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.CreateSaveGameObject
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* SaveGameClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USaveGame* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USaveGame* UGameplayStatics::CreateSaveGameObject(class UClass* SaveGameClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.CreateSaveGameObject");
|
|
|
|
UGameplayStatics_CreateSaveGameObject_Params params;
|
|
params.SaveGameClass = SaveGameClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.CreatePlayer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ControllerId (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSpawnPawn (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* UGameplayStatics::CreatePlayer(class UObject* WorldContextObject, int ControllerId, bool bSpawnPawn)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.CreatePlayer");
|
|
|
|
UGameplayStatics_CreatePlayer_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ControllerId = ControllerId;
|
|
params.bSpawnPawn = bSpawnPawn;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ClearSoundMixModifiers
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::ClearSoundMixModifiers(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ClearSoundMixModifiers");
|
|
|
|
UGameplayStatics_ClearSoundMixModifiers_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ClearSoundMixClassOverride
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundMix* InSoundMixModifier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundClass* InSoundClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::ClearSoundMixClassOverride(class UObject* WorldContextObject, class USoundMix* InSoundMixModifier, class USoundClass* InSoundClass, float FadeOutTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ClearSoundMixClassOverride");
|
|
|
|
UGameplayStatics_ClearSoundMixClassOverride_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InSoundMixModifier = InSoundMixModifier;
|
|
params.InSoundClass = InSoundClass;
|
|
params.FadeOutTime = FadeOutTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.CancelAsyncLoading
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UGameplayStatics::CancelAsyncLoading()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.CancelAsyncLoading");
|
|
|
|
UGameplayStatics_CancelAsyncLoading_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.BreakHitResult
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bBlockingHit (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool bInitialOverlap (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Time (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Distance (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector ImpactPoint (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Normal (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector ImpactNormal (Parm, OutParm, IsPlainOldData)
|
|
// class UPhysicalMaterial* PhysMat (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* HitActor (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* HitComponent (Parm, OutParm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName HitBoneName (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int HitItem (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int FaceIndex (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector TraceStart (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector TraceEnd (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UGameplayStatics::BreakHitResult(const struct FHitResult& Hit, bool* bBlockingHit, bool* bInitialOverlap, float* Time, float* Distance, struct FVector* Location, struct FVector* ImpactPoint, struct FVector* Normal, struct FVector* ImpactNormal, class UPhysicalMaterial** PhysMat, class AActor** HitActor, class UPrimitiveComponent** HitComponent, struct FName* HitBoneName, int* HitItem, int* FaceIndex, struct FVector* TraceStart, struct FVector* TraceEnd)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.BreakHitResult");
|
|
|
|
UGameplayStatics_BreakHitResult_Params params;
|
|
params.Hit = Hit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (bBlockingHit != nullptr)
|
|
*bBlockingHit = params.bBlockingHit;
|
|
if (bInitialOverlap != nullptr)
|
|
*bInitialOverlap = params.bInitialOverlap;
|
|
if (Time != nullptr)
|
|
*Time = params.Time;
|
|
if (Distance != nullptr)
|
|
*Distance = params.Distance;
|
|
if (Location != nullptr)
|
|
*Location = params.Location;
|
|
if (ImpactPoint != nullptr)
|
|
*ImpactPoint = params.ImpactPoint;
|
|
if (Normal != nullptr)
|
|
*Normal = params.Normal;
|
|
if (ImpactNormal != nullptr)
|
|
*ImpactNormal = params.ImpactNormal;
|
|
if (PhysMat != nullptr)
|
|
*PhysMat = params.PhysMat;
|
|
if (HitActor != nullptr)
|
|
*HitActor = params.HitActor;
|
|
if (HitComponent != nullptr)
|
|
*HitComponent = params.HitComponent;
|
|
if (HitBoneName != nullptr)
|
|
*HitBoneName = params.HitBoneName;
|
|
if (HitItem != nullptr)
|
|
*HitItem = params.HitItem;
|
|
if (FaceIndex != nullptr)
|
|
*FaceIndex = params.FaceIndex;
|
|
if (TraceStart != nullptr)
|
|
*TraceStart = params.TraceStart;
|
|
if (TraceEnd != nullptr)
|
|
*TraceEnd = params.TraceEnd;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.BlueprintSuggestProjectileVelocity
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector TossVelocity (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector StartLocation (Parm, IsPlainOldData)
|
|
// struct FVector EndLocation (Parm, IsPlainOldData)
|
|
// float LaunchSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OverrideGravityZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESuggestProjVelocityTraceOption> TraceOption (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float CollisionRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFavorHighArc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDrawDebug (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::BlueprintSuggestProjectileVelocity(class UObject* WorldContextObject, bool bDrawDebug, const struct FVector& StartLocation, const struct FVector& EndLocation, float LaunchSpeed, float OverrideGravityZ, TEnumAsByte<ESuggestProjVelocityTraceOption> TraceOption, float CollisionRadius, bool bFavorHighArc, struct FVector* TossVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.BlueprintSuggestProjectileVelocity");
|
|
|
|
UGameplayStatics_BlueprintSuggestProjectileVelocity_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.StartLocation = StartLocation;
|
|
params.EndLocation = EndLocation;
|
|
params.LaunchSpeed = LaunchSpeed;
|
|
params.OverrideGravityZ = OverrideGravityZ;
|
|
params.TraceOption = TraceOption;
|
|
params.CollisionRadius = CollisionRadius;
|
|
params.bFavorHighArc = bFavorHighArc;
|
|
params.bDrawDebug = bDrawDebug;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (TossVelocity != nullptr)
|
|
*TossVelocity = params.TossVelocity;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.Blueprint_PredictProjectilePath_ByTraceChannel
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// TArray<struct FVector> OutPathPositions (Parm, OutParm, ZeroConstructor)
|
|
// struct FVector OutLastTraceDestination (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector startPos (Parm, IsPlainOldData)
|
|
// struct FVector LaunchVelocity (Parm, IsPlainOldData)
|
|
// bool bTracePath (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ProjectileRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECollisionChannel> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DrawDebugTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float SimFrequency (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxSimTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OverrideGravityZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::Blueprint_PredictProjectilePath_ByTraceChannel(class UObject* WorldContextObject, float OverrideGravityZ, float MaxSimTime, float SimFrequency, const struct FVector& startPos, const struct FVector& LaunchVelocity, bool bTracePath, float ProjectileRadius, TEnumAsByte<ECollisionChannel> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawDebugTime, struct FVector* OutLastTraceDestination, TArray<struct FVector>* OutPathPositions, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.Blueprint_PredictProjectilePath_ByTraceChannel");
|
|
|
|
UGameplayStatics_Blueprint_PredictProjectilePath_ByTraceChannel_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.startPos = startPos;
|
|
params.LaunchVelocity = LaunchVelocity;
|
|
params.bTracePath = bTracePath;
|
|
params.ProjectileRadius = ProjectileRadius;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.DrawDebugTime = DrawDebugTime;
|
|
params.SimFrequency = SimFrequency;
|
|
params.MaxSimTime = MaxSimTime;
|
|
params.OverrideGravityZ = OverrideGravityZ;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
if (OutPathPositions != nullptr)
|
|
*OutPathPositions = params.OutPathPositions;
|
|
if (OutLastTraceDestination != nullptr)
|
|
*OutLastTraceDestination = params.OutLastTraceDestination;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.Blueprint_PredictProjectilePath_ByObjectType
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// TArray<struct FVector> OutPathPositions (Parm, OutParm, ZeroConstructor)
|
|
// struct FVector OutLastTraceDestination (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector startPos (Parm, IsPlainOldData)
|
|
// struct FVector LaunchVelocity (Parm, IsPlainOldData)
|
|
// bool bTracePath (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ProjectileRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DrawDebugTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float SimFrequency (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxSimTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OverrideGravityZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::Blueprint_PredictProjectilePath_ByObjectType(class UObject* WorldContextObject, float OverrideGravityZ, float MaxSimTime, float SimFrequency, const struct FVector& startPos, const struct FVector& LaunchVelocity, bool bTracePath, float ProjectileRadius, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawDebugTime, struct FVector* OutLastTraceDestination, TArray<struct FVector>* OutPathPositions, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.Blueprint_PredictProjectilePath_ByObjectType");
|
|
|
|
UGameplayStatics_Blueprint_PredictProjectilePath_ByObjectType_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.startPos = startPos;
|
|
params.LaunchVelocity = LaunchVelocity;
|
|
params.bTracePath = bTracePath;
|
|
params.ProjectileRadius = ProjectileRadius;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.DrawDebugTime = DrawDebugTime;
|
|
params.SimFrequency = SimFrequency;
|
|
params.MaxSimTime = MaxSimTime;
|
|
params.OverrideGravityZ = OverrideGravityZ;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
if (OutPathPositions != nullptr)
|
|
*OutPathPositions = params.OutPathPositions;
|
|
if (OutLastTraceDestination != nullptr)
|
|
*OutLastTraceDestination = params.OutLastTraceDestination;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.Blueprint_PredictProjectilePath_Advanced
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPredictProjectilePathParams PredictParams (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FPredictProjectilePathResult PredictResult (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::Blueprint_PredictProjectilePath_Advanced(class UObject* WorldContextObject, const struct FPredictProjectilePathParams& PredictParams, struct FPredictProjectilePathResult* PredictResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.Blueprint_PredictProjectilePath_Advanced");
|
|
|
|
UGameplayStatics_Blueprint_PredictProjectilePath_Advanced_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PredictParams = PredictParams;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PredictResult != nullptr)
|
|
*PredictResult = params.PredictResult;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.BeginSpawningActorFromClass
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ActorClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform SpawnTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bNoCollisionFail (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Owner (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UGameplayStatics::BeginSpawningActorFromClass(class UObject* WorldContextObject, class UClass* ActorClass, const struct FTransform& SpawnTransform, bool bNoCollisionFail, class AActor* Owner)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.BeginSpawningActorFromClass");
|
|
|
|
UGameplayStatics_BeginSpawningActorFromClass_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ActorClass = ActorClass;
|
|
params.SpawnTransform = SpawnTransform;
|
|
params.bNoCollisionFail = bNoCollisionFail;
|
|
params.Owner = Owner;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.BeginSpawningActorFromBlueprint
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UBlueprint* Blueprint (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform SpawnTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bNoCollisionFail (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UGameplayStatics::BeginSpawningActorFromBlueprint(class UObject* WorldContextObject, class UBlueprint* Blueprint, const struct FTransform& SpawnTransform, bool bNoCollisionFail)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.BeginSpawningActorFromBlueprint");
|
|
|
|
UGameplayStatics_BeginSpawningActorFromBlueprint_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Blueprint = Blueprint;
|
|
params.SpawnTransform = SpawnTransform;
|
|
params.bNoCollisionFail = bNoCollisionFail;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.BeginDeferredActorSpawnFromClass
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ActorClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform SpawnTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// ESpawnActorCollisionHandlingMethod CollisionHandlingOverride (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Owner (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UGameplayStatics::BeginDeferredActorSpawnFromClass(class UObject* WorldContextObject, class UClass* ActorClass, const struct FTransform& SpawnTransform, ESpawnActorCollisionHandlingMethod CollisionHandlingOverride, class AActor* Owner)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.BeginDeferredActorSpawnFromClass");
|
|
|
|
UGameplayStatics_BeginDeferredActorSpawnFromClass_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ActorClass = ActorClass;
|
|
params.SpawnTransform = SpawnTransform;
|
|
params.CollisionHandlingOverride = CollisionHandlingOverride;
|
|
params.Owner = Owner;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.AreSubtitlesEnabled
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::AreSubtitlesEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.AreSubtitlesEnabled");
|
|
|
|
UGameplayStatics_AreSubtitlesEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.AreAnyListenersWithinRange
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// float MaximumRange (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::AreAnyListenersWithinRange(class UObject* WorldContextObject, const struct FVector& Location, float MaximumRange)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.AreAnyListenersWithinRange");
|
|
|
|
UGameplayStatics_AreAnyListenersWithinRange_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Location = Location;
|
|
params.MaximumRange = MaximumRange;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ApplyRadialDamageWithFalloff
|
|
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BaseDamage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MinimumDamage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float DamageInnerRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DamageOuterRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DamageFalloff (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* DamageTypeClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> IgnoreActors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AController* InstigatedByController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECollisionChannel> DamagePreventionChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::ApplyRadialDamageWithFalloff(class UObject* WorldContextObject, float BaseDamage, float MinimumDamage, const struct FVector& Origin, float DamageInnerRadius, float DamageOuterRadius, float DamageFalloff, class UClass* DamageTypeClass, TArray<class AActor*> IgnoreActors, class AActor* DamageCauser, class AController* InstigatedByController, TEnumAsByte<ECollisionChannel> DamagePreventionChannel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ApplyRadialDamageWithFalloff");
|
|
|
|
UGameplayStatics_ApplyRadialDamageWithFalloff_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.BaseDamage = BaseDamage;
|
|
params.MinimumDamage = MinimumDamage;
|
|
params.Origin = Origin;
|
|
params.DamageInnerRadius = DamageInnerRadius;
|
|
params.DamageOuterRadius = DamageOuterRadius;
|
|
params.DamageFalloff = DamageFalloff;
|
|
params.DamageTypeClass = DamageTypeClass;
|
|
params.IgnoreActors = IgnoreActors;
|
|
params.DamageCauser = DamageCauser;
|
|
params.InstigatedByController = InstigatedByController;
|
|
params.DamagePreventionChannel = DamagePreventionChannel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ApplyRadialDamage
|
|
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BaseDamage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float DamageRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* DamageTypeClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> IgnoreActors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AController* InstigatedByController (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDoFullDamage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECollisionChannel> DamagePreventionChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameplayStatics::ApplyRadialDamage(class UObject* WorldContextObject, float BaseDamage, const struct FVector& Origin, float DamageRadius, class UClass* DamageTypeClass, TArray<class AActor*> IgnoreActors, class AActor* DamageCauser, class AController* InstigatedByController, bool bDoFullDamage, TEnumAsByte<ECollisionChannel> DamagePreventionChannel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ApplyRadialDamage");
|
|
|
|
UGameplayStatics_ApplyRadialDamage_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.BaseDamage = BaseDamage;
|
|
params.Origin = Origin;
|
|
params.DamageRadius = DamageRadius;
|
|
params.DamageTypeClass = DamageTypeClass;
|
|
params.IgnoreActors = IgnoreActors;
|
|
params.DamageCauser = DamageCauser;
|
|
params.InstigatedByController = InstigatedByController;
|
|
params.bDoFullDamage = bDoFullDamage;
|
|
params.DamagePreventionChannel = DamagePreventionChannel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ApplyPointDamage
|
|
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* DamagedActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BaseDamage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector HitFromDirection (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FHitResult HitInfo (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class AController* EventInstigator (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* DamageTypeClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::ApplyPointDamage(class AActor* DamagedActor, float BaseDamage, const struct FVector& HitFromDirection, const struct FHitResult& HitInfo, class AController* EventInstigator, class AActor* DamageCauser, class UClass* DamageTypeClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ApplyPointDamage");
|
|
|
|
UGameplayStatics_ApplyPointDamage_Params params;
|
|
params.DamagedActor = DamagedActor;
|
|
params.BaseDamage = BaseDamage;
|
|
params.HitFromDirection = HitFromDirection;
|
|
params.HitInfo = HitInfo;
|
|
params.EventInstigator = EventInstigator;
|
|
params.DamageCauser = DamageCauser;
|
|
params.DamageTypeClass = DamageTypeClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ApplyDamage
|
|
// (Final, BlueprintAuthorityOnly, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* DamagedActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BaseDamage (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AController* EventInstigator (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* DamageCauser (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* DamageTypeClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameplayStatics::ApplyDamage(class AActor* DamagedActor, float BaseDamage, class AController* EventInstigator, class AActor* DamageCauser, class UClass* DamageTypeClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ApplyDamage");
|
|
|
|
UGameplayStatics_ApplyDamage_Params params;
|
|
params.DamagedActor = DamagedActor;
|
|
params.BaseDamage = BaseDamage;
|
|
params.EventInstigator = EventInstigator;
|
|
params.DamageCauser = DamageCauser;
|
|
params.DamageTypeClass = DamageTypeClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameplayStatics.ActivateReverbEffect
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UReverbEffect* ReverbEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName TagName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Priority (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Volume (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameplayStatics::ActivateReverbEffect(class UObject* WorldContextObject, class UReverbEffect* ReverbEffect, const struct FName& TagName, float Priority, float Volume, float FadeTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameplayStatics.ActivateReverbEffect");
|
|
|
|
UGameplayStatics_ActivateReverbEffect_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.ReverbEffect = ReverbEffect;
|
|
params.TagName = TagName;
|
|
params.Priority = Priority;
|
|
params.Volume = Volume;
|
|
params.FadeTime = FadeTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopCameraShake
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCameraShake* ShakeInstance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bImmediately (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StopCameraShake(class UCameraShake* ShakeInstance, bool bImmediately)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopCameraShake");
|
|
|
|
APlayerCameraManager_StopCameraShake_Params params;
|
|
params.ShakeInstance = ShakeInstance;
|
|
params.bImmediately = bImmediately;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopCameraFade
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void APlayerCameraManager::StopCameraFade()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopCameraFade");
|
|
|
|
APlayerCameraManager_StopCameraFade_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopCameraAnimInst
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCameraAnimInst* AnimInst (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bImmediate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StopCameraAnimInst(class UCameraAnimInst* AnimInst, bool bImmediate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopCameraAnimInst");
|
|
|
|
APlayerCameraManager_StopCameraAnimInst_Params params;
|
|
params.AnimInst = AnimInst;
|
|
params.bImmediate = bImmediate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopAllInstancesOfCameraShake
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* Shake (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bImmediately (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StopAllInstancesOfCameraShake(class UClass* Shake, bool bImmediately)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopAllInstancesOfCameraShake");
|
|
|
|
APlayerCameraManager_StopAllInstancesOfCameraShake_Params params;
|
|
params.Shake = Shake;
|
|
params.bImmediately = bImmediately;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopAllInstancesOfCameraAnim
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCameraAnim* Anim (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bImmediate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StopAllInstancesOfCameraAnim(class UCameraAnim* Anim, bool bImmediate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopAllInstancesOfCameraAnim");
|
|
|
|
APlayerCameraManager_StopAllInstancesOfCameraAnim_Params params;
|
|
params.Anim = Anim;
|
|
params.bImmediate = bImmediate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopAllCameraShakes
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bImmediately (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StopAllCameraShakes(bool bImmediately)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopAllCameraShakes");
|
|
|
|
APlayerCameraManager_StopAllCameraShakes_Params params;
|
|
params.bImmediately = bImmediately;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StopAllCameraAnims
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bImmediate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StopAllCameraAnims(bool bImmediate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StopAllCameraAnims");
|
|
|
|
APlayerCameraManager_StopAllCameraAnims_Params params;
|
|
params.bImmediate = bImmediate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.StartCameraFade
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float FromAlpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ToAlpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Color (Parm, IsPlainOldData)
|
|
// bool bShouldFadeAudio (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHoldWhenFinished (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::StartCameraFade(float FromAlpha, float ToAlpha, float Duration, const struct FLinearColor& Color, bool bShouldFadeAudio, bool bHoldWhenFinished)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.StartCameraFade");
|
|
|
|
APlayerCameraManager_StartCameraFade_Params params;
|
|
params.FromAlpha = FromAlpha;
|
|
params.ToAlpha = ToAlpha;
|
|
params.Duration = Duration;
|
|
params.Color = Color;
|
|
params.bShouldFadeAudio = bShouldFadeAudio;
|
|
params.bHoldWhenFinished = bHoldWhenFinished;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.SetManualCameraFade
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float InFadeAmount (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Color (Parm, IsPlainOldData)
|
|
// bool bInFadeAudio (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::SetManualCameraFade(float InFadeAmount, const struct FLinearColor& Color, bool bInFadeAudio)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.SetManualCameraFade");
|
|
|
|
APlayerCameraManager_SetManualCameraFade_Params params;
|
|
params.InFadeAmount = InFadeAmount;
|
|
params.Color = Color;
|
|
params.bInFadeAudio = bInFadeAudio;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.RemoveCameraModifier
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCameraModifier* ModifierToRemove (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerCameraManager::RemoveCameraModifier(class UCameraModifier* ModifierToRemove)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.RemoveCameraModifier");
|
|
|
|
APlayerCameraManager_RemoveCameraModifier_Params params;
|
|
params.ModifierToRemove = ModifierToRemove;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.RemoveCameraLensEffect
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AEmitterCameraLensEffectBase* Emitter (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::RemoveCameraLensEffect(class AEmitterCameraLensEffectBase* Emitter)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.RemoveCameraLensEffect");
|
|
|
|
APlayerCameraManager_RemoveCameraLensEffect_Params params;
|
|
params.Emitter = Emitter;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.PlayCameraShake
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* ShakeClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECameraAnimPlaySpace> PlaySpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator UserPlaySpaceRot (Parm, IsPlainOldData)
|
|
// class UCameraShake* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UCameraShake* APlayerCameraManager::PlayCameraShake(class UClass* ShakeClass, float Scale, TEnumAsByte<ECameraAnimPlaySpace> PlaySpace, const struct FRotator& UserPlaySpaceRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.PlayCameraShake");
|
|
|
|
APlayerCameraManager_PlayCameraShake_Params params;
|
|
params.ShakeClass = ShakeClass;
|
|
params.Scale = Scale;
|
|
params.PlaySpace = PlaySpace;
|
|
params.UserPlaySpaceRot = UserPlaySpaceRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.PlayCameraAnim
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCameraAnim* Anim (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Rate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendInTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendOutTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLoop (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRandomStartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ECameraAnimPlaySpace> PlaySpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator UserPlaySpaceRot (Parm, IsPlainOldData)
|
|
// class UCameraAnimInst* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UCameraAnimInst* APlayerCameraManager::PlayCameraAnim(class UCameraAnim* Anim, float Rate, float Scale, float BlendInTime, float BlendOutTime, bool bLoop, bool bRandomStartTime, float Duration, TEnumAsByte<ECameraAnimPlaySpace> PlaySpace, const struct FRotator& UserPlaySpaceRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.PlayCameraAnim");
|
|
|
|
APlayerCameraManager_PlayCameraAnim_Params params;
|
|
params.Anim = Anim;
|
|
params.Rate = Rate;
|
|
params.Scale = Scale;
|
|
params.BlendInTime = BlendInTime;
|
|
params.BlendOutTime = BlendOutTime;
|
|
params.bLoop = bLoop;
|
|
params.bRandomStartTime = bRandomStartTime;
|
|
params.Duration = Duration;
|
|
params.PlaySpace = PlaySpace;
|
|
params.UserPlaySpaceRot = UserPlaySpaceRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.PhotographyCameraModify
|
|
// (BlueprintCosmetic, Native, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FVector NewCameraLocation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector PreviousCameraLocation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector OriginalCameraLocation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector ResultCameraLocation (Parm, OutParm, IsPlainOldData)
|
|
|
|
void APlayerCameraManager::PhotographyCameraModify(const struct FVector& NewCameraLocation, const struct FVector& PreviousCameraLocation, const struct FVector& OriginalCameraLocation, struct FVector* ResultCameraLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.PhotographyCameraModify");
|
|
|
|
APlayerCameraManager_PhotographyCameraModify_Params params;
|
|
params.NewCameraLocation = NewCameraLocation;
|
|
params.PreviousCameraLocation = PreviousCameraLocation;
|
|
params.OriginalCameraLocation = OriginalCameraLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ResultCameraLocation != nullptr)
|
|
*ResultCameraLocation = params.ResultCameraLocation;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.OnPhotographySessionStart
|
|
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)
|
|
|
|
void APlayerCameraManager::OnPhotographySessionStart()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.OnPhotographySessionStart");
|
|
|
|
APlayerCameraManager_OnPhotographySessionStart_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.OnPhotographySessionEnd
|
|
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)
|
|
|
|
void APlayerCameraManager::OnPhotographySessionEnd()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.OnPhotographySessionEnd");
|
|
|
|
APlayerCameraManager_OnPhotographySessionEnd_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.OnPhotographyMultiPartCaptureStart
|
|
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)
|
|
|
|
void APlayerCameraManager::OnPhotographyMultiPartCaptureStart()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.OnPhotographyMultiPartCaptureStart");
|
|
|
|
APlayerCameraManager_OnPhotographyMultiPartCaptureStart_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.OnPhotographyMultiPartCaptureEnd
|
|
// (BlueprintCosmetic, Native, Event, Public, BlueprintEvent)
|
|
|
|
void APlayerCameraManager::OnPhotographyMultiPartCaptureEnd()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.OnPhotographyMultiPartCaptureEnd");
|
|
|
|
APlayerCameraManager_OnPhotographyMultiPartCaptureEnd_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.GetOwningPlayerController
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class APlayerController* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class APlayerController* APlayerCameraManager::GetOwningPlayerController()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.GetOwningPlayerController");
|
|
|
|
APlayerCameraManager_GetOwningPlayerController_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.GetFOVAngle
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float APlayerCameraManager::GetFOVAngle()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.GetFOVAngle");
|
|
|
|
APlayerCameraManager_GetFOVAngle_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.GetCameraRotation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator APlayerCameraManager::GetCameraRotation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.GetCameraRotation");
|
|
|
|
APlayerCameraManager_GetCameraRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.GetCameraLocation
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector APlayerCameraManager::GetCameraLocation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.GetCameraLocation");
|
|
|
|
APlayerCameraManager_GetCameraLocation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.FindCameraModifierByClass
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* ModifierClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCameraModifier* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UCameraModifier* APlayerCameraManager::FindCameraModifierByClass(class UClass* ModifierClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.FindCameraModifierByClass");
|
|
|
|
APlayerCameraManager_FindCameraModifierByClass_Params params;
|
|
params.ModifierClass = ModifierClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.ClearCameraLensEffects
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void APlayerCameraManager::ClearCameraLensEffects()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.ClearCameraLensEffects");
|
|
|
|
APlayerCameraManager_ClearCameraLensEffects_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.BlueprintUpdateCamera
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* CameraTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewCameraLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator NewCameraRotation (Parm, OutParm, IsPlainOldData)
|
|
// float NewCameraFOV (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool APlayerCameraManager::BlueprintUpdateCamera(class AActor* CameraTarget, struct FVector* NewCameraLocation, struct FRotator* NewCameraRotation, float* NewCameraFOV)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.BlueprintUpdateCamera");
|
|
|
|
APlayerCameraManager_BlueprintUpdateCamera_Params params;
|
|
params.CameraTarget = CameraTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (NewCameraLocation != nullptr)
|
|
*NewCameraLocation = params.NewCameraLocation;
|
|
if (NewCameraRotation != nullptr)
|
|
*NewCameraRotation = params.NewCameraRotation;
|
|
if (NewCameraFOV != nullptr)
|
|
*NewCameraFOV = params.NewCameraFOV;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.AddNewCameraModifier
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* ModifierClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCameraModifier* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UCameraModifier* APlayerCameraManager::AddNewCameraModifier(class UClass* ModifierClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.AddNewCameraModifier");
|
|
|
|
APlayerCameraManager_AddNewCameraModifier_Params params;
|
|
params.ModifierClass = ModifierClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerCameraManager.AddCameraLensEffect
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* LensEffectEmitterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AEmitterCameraLensEffectBase* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AEmitterCameraLensEffectBase* APlayerCameraManager::AddCameraLensEffect(class UClass* LensEffectEmitterClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerCameraManager.AddCameraLensEffect");
|
|
|
|
APlayerCameraManager_AddCameraLensEffect_Params params;
|
|
params.LensEffectEmitterClass = LensEffectEmitterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DefaultPawn.TurnAtRate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Rate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADefaultPawn::TurnAtRate(float Rate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DefaultPawn.TurnAtRate");
|
|
|
|
ADefaultPawn_TurnAtRate_Params params;
|
|
params.Rate = Rate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DefaultPawn.MoveUp_World
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADefaultPawn::MoveUp_World(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DefaultPawn.MoveUp_World");
|
|
|
|
ADefaultPawn_MoveUp_World_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DefaultPawn.MoveRight
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADefaultPawn::MoveRight(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DefaultPawn.MoveRight");
|
|
|
|
ADefaultPawn_MoveRight_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DefaultPawn.MoveForward
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Val (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADefaultPawn::MoveForward(float Val)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DefaultPawn.MoveForward");
|
|
|
|
ADefaultPawn_MoveForward_Params params;
|
|
params.Val = Val;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DefaultPawn.LookUpAtRate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Rate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADefaultPawn::LookUpAtRate(float Rate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DefaultPawn.LookUpAtRate");
|
|
|
|
ADefaultPawn_LookUpAtRate_Params params;
|
|
params.Rate = Rate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SphereComponent.SetSphereRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InSphereRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateOverlaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USphereComponent::SetSphereRadius(float InSphereRadius, bool bUpdateOverlaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SphereComponent.SetSphereRadius");
|
|
|
|
USphereComponent_SetSphereRadius_Params params;
|
|
params.InSphereRadius = InSphereRadius;
|
|
params.bUpdateOverlaps = bUpdateOverlaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SphereComponent.GetUnscaledSphereRadius
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USphereComponent::GetUnscaledSphereRadius()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SphereComponent.GetUnscaledSphereRadius");
|
|
|
|
USphereComponent_GetUnscaledSphereRadius_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SphereComponent.GetShapeScale
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USphereComponent::GetShapeScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SphereComponent.GetShapeScale");
|
|
|
|
USphereComponent_GetShapeScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SphereComponent.GetScaledSphereRadius
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USphereComponent::GetScaledSphereRadius()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SphereComponent.GetScaledSphereRadius");
|
|
|
|
USphereComponent_GetScaledSphereRadius_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BoxComponent.SetBoxExtent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector InBoxExtent (Parm, IsPlainOldData)
|
|
// bool bUpdateOverlaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBoxComponent::SetBoxExtent(const struct FVector& InBoxExtent, bool bUpdateOverlaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BoxComponent.SetBoxExtent");
|
|
|
|
UBoxComponent_SetBoxExtent_Params params;
|
|
params.InBoxExtent = InBoxExtent;
|
|
params.bUpdateOverlaps = bUpdateOverlaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BoxComponent.GetUnscaledBoxExtent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UBoxComponent::GetUnscaledBoxExtent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BoxComponent.GetUnscaledBoxExtent");
|
|
|
|
UBoxComponent_GetUnscaledBoxExtent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BoxComponent.GetScaledBoxExtent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UBoxComponent::GetScaledBoxExtent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BoxComponent.GetScaledBoxExtent");
|
|
|
|
UBoxComponent_GetScaledBoxExtent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintAsyncActionBase.Activate
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UBlueprintAsyncActionBase::Activate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintAsyncActionBase.Activate");
|
|
|
|
UBlueprintAsyncActionBase_Activate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.UpdateInstanceTransform
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int InstanceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform NewInstanceTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bWorldSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bMarkRenderStateDirty (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTeleport (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInstancedStaticMeshComponent::UpdateInstanceTransform(int InstanceIndex, const struct FTransform& NewInstanceTransform, bool bWorldSpace, bool bMarkRenderStateDirty, bool bTeleport)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.UpdateInstanceTransform");
|
|
|
|
UInstancedStaticMeshComponent_UpdateInstanceTransform_Params params;
|
|
params.InstanceIndex = InstanceIndex;
|
|
params.NewInstanceTransform = NewInstanceTransform;
|
|
params.bWorldSpace = bWorldSpace;
|
|
params.bMarkRenderStateDirty = bMarkRenderStateDirty;
|
|
params.bTeleport = bTeleport;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.SetCullDistances
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int StartCullDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int EndCullDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInstancedStaticMeshComponent::SetCullDistances(int StartCullDistance, int EndCullDistance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.SetCullDistances");
|
|
|
|
UInstancedStaticMeshComponent_SetCullDistances_Params params;
|
|
params.StartCullDistance = StartCullDistance;
|
|
params.EndCullDistance = EndCullDistance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.RemoveInstance
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InstanceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInstancedStaticMeshComponent::RemoveInstance(int InstanceIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.RemoveInstance");
|
|
|
|
UInstancedStaticMeshComponent_RemoveInstance_Params params;
|
|
params.InstanceIndex = InstanceIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.GetInstanceTransform
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int InstanceIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform OutInstanceTransform (Parm, OutParm, IsPlainOldData)
|
|
// bool bWorldSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInstancedStaticMeshComponent::GetInstanceTransform(int InstanceIndex, bool bWorldSpace, struct FTransform* OutInstanceTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.GetInstanceTransform");
|
|
|
|
UInstancedStaticMeshComponent_GetInstanceTransform_Params params;
|
|
params.InstanceIndex = InstanceIndex;
|
|
params.bWorldSpace = bWorldSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutInstanceTransform != nullptr)
|
|
*OutInstanceTransform = params.OutInstanceTransform;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.GetInstancesOverlappingSphere
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector Center (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSphereInWorldSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<int> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<int> UInstancedStaticMeshComponent::GetInstancesOverlappingSphere(const struct FVector& Center, float Radius, bool bSphereInWorldSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.GetInstancesOverlappingSphere");
|
|
|
|
UInstancedStaticMeshComponent_GetInstancesOverlappingSphere_Params params;
|
|
params.Center = Center;
|
|
params.Radius = Radius;
|
|
params.bSphereInWorldSpace = bSphereInWorldSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.GetInstancesOverlappingBox
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FBox Box (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bBoxInWorldSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<int> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<int> UInstancedStaticMeshComponent::GetInstancesOverlappingBox(const struct FBox& Box, bool bBoxInWorldSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.GetInstancesOverlappingBox");
|
|
|
|
UInstancedStaticMeshComponent_GetInstancesOverlappingBox_Params params;
|
|
params.Box = Box;
|
|
params.bBoxInWorldSpace = bBoxInWorldSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.GetInstanceCount
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UInstancedStaticMeshComponent::GetInstanceCount()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.GetInstanceCount");
|
|
|
|
UInstancedStaticMeshComponent_GetInstanceCount_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.ClearInstances
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UInstancedStaticMeshComponent::ClearInstances()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.ClearInstances");
|
|
|
|
UInstancedStaticMeshComponent_ClearInstances_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.AddInstanceWorldSpace
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform WorldTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UInstancedStaticMeshComponent::AddInstanceWorldSpace(const struct FTransform& WorldTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.AddInstanceWorldSpace");
|
|
|
|
UInstancedStaticMeshComponent_AddInstanceWorldSpace_Params params;
|
|
params.WorldTransform = WorldTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InstancedStaticMeshComponent.AddInstance
|
|
// (Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTransform InstanceTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UInstancedStaticMeshComponent::AddInstance(const struct FTransform& InstanceTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InstancedStaticMeshComponent.AddInstance");
|
|
|
|
UInstancedStaticMeshComponent_AddInstance_Params params;
|
|
params.InstanceTransform = InstanceTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.HierarchicalInstancedStaticMeshComponent.RemoveInstances
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> InstancesToRemove (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UHierarchicalInstancedStaticMeshComponent::RemoveInstances(TArray<int> InstancesToRemove)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.HierarchicalInstancedStaticMeshComponent.RemoveInstances");
|
|
|
|
UHierarchicalInstancedStaticMeshComponent_RemoveInstances_Params params;
|
|
params.InstancesToRemove = InstancesToRemove;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInterface.SetStreamingTextureMipOffset
|
|
// (RequiredAPI, Native, Public, BlueprintCallable, Const)
|
|
// Parameters:
|
|
// int NewMipOffset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInterface::SetStreamingTextureMipOffset(int NewMipOffset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInterface.SetStreamingTextureMipOffset");
|
|
|
|
UMaterialInterface_SetStreamingTextureMipOffset_Params params;
|
|
params.NewMipOffset = NewMipOffset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInterface.SetForceMipLevelsToBeResident
|
|
// (RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool OverrideForceMiplevelsToBeResident (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bForceMiplevelsToBeResidentValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ForceDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int CinematicTextureGroups (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInterface::SetForceMipLevelsToBeResident(bool OverrideForceMiplevelsToBeResident, bool bForceMiplevelsToBeResidentValue, float ForceDuration, int CinematicTextureGroups)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInterface.SetForceMipLevelsToBeResident");
|
|
|
|
UMaterialInterface_SetForceMipLevelsToBeResident_Params params;
|
|
params.OverrideForceMiplevelsToBeResident = OverrideForceMiplevelsToBeResident;
|
|
params.bForceMiplevelsToBeResidentValue = bForceMiplevelsToBeResidentValue;
|
|
params.ForceDuration = ForceDuration;
|
|
params.CinematicTextureGroups = CinematicTextureGroups;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInterface.GetPhysicalMaterial
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPhysicalMaterial* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UPhysicalMaterial* UMaterialInterface::GetPhysicalMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInterface.GetPhysicalMaterial");
|
|
|
|
UMaterialInterface_GetPhysicalMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInterface.GetBaseMaterial
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterial* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterial* UMaterialInterface::GetBaseMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInterface.GetBaseMaterial");
|
|
|
|
UMaterialInterface_GetBaseMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotify.Received_Notify
|
|
// (Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* meshComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UAnimSequenceBase* Animation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimNotify::Received_Notify(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotify.Received_Notify");
|
|
|
|
UAnimNotify_Received_Notify_Params params;
|
|
params.meshComp = meshComp;
|
|
params.Animation = Animation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotify.GetNotifyName
|
|
// (Native, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UAnimNotify::GetNotifyName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotify.GetNotifyName");
|
|
|
|
UAnimNotify_GetNotifyName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotifyState.Received_NotifyTick
|
|
// (Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* meshComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UAnimSequenceBase* Animation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FrameDeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimNotifyState::Received_NotifyTick(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation, float FrameDeltaTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotifyState.Received_NotifyTick");
|
|
|
|
UAnimNotifyState_Received_NotifyTick_Params params;
|
|
params.meshComp = meshComp;
|
|
params.Animation = Animation;
|
|
params.FrameDeltaTime = FrameDeltaTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotifyState.Received_NotifyEnd
|
|
// (Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* meshComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UAnimSequenceBase* Animation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimNotifyState::Received_NotifyEnd(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotifyState.Received_NotifyEnd");
|
|
|
|
UAnimNotifyState_Received_NotifyEnd_Params params;
|
|
params.meshComp = meshComp;
|
|
params.Animation = Animation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotifyState.Received_NotifyBegin
|
|
// (Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* meshComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UAnimSequenceBase* Animation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TotalDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAnimNotifyState::Received_NotifyBegin(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation, float TotalDuration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotifyState.Received_NotifyBegin");
|
|
|
|
UAnimNotifyState_Received_NotifyBegin_Params params;
|
|
params.meshComp = meshComp;
|
|
params.Animation = Animation;
|
|
params.TotalDuration = TotalDuration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotifyState.GetNotifyName
|
|
// (Native, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UAnimNotifyState::GetNotifyName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotifyState.GetNotifyName");
|
|
|
|
UAnimNotifyState_GetNotifyName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraActor.GetAutoActivatePlayerIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int ACameraActor::GetAutoActivatePlayerIndex()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraActor.GetAutoActivatePlayerIndex");
|
|
|
|
ACameraActor_GetAutoActivatePlayerIndex_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AmbientSound.Stop
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void AAmbientSound::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AmbientSound.Stop");
|
|
|
|
AAmbientSound_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AmbientSound.Play
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AAmbientSound::Play(float StartTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AmbientSound.Play");
|
|
|
|
AAmbientSound_Play_Params params;
|
|
params.StartTime = StartTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AmbientSound.FadeOut
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FadeOutDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeVolumeLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AAmbientSound::FadeOut(float FadeOutDuration, float FadeVolumeLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AmbientSound.FadeOut");
|
|
|
|
AAmbientSound_FadeOut_Params params;
|
|
params.FadeOutDuration = FadeOutDuration;
|
|
params.FadeVolumeLevel = FadeVolumeLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AmbientSound.FadeIn
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FadeInDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeVolumeLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AAmbientSound::FadeIn(float FadeInDuration, float FadeVolumeLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AmbientSound.FadeIn");
|
|
|
|
AAmbientSound_FadeIn_Params params;
|
|
params.FadeInDuration = FadeInDuration;
|
|
params.FadeVolumeLevel = FadeVolumeLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AmbientSound.AdjustVolume
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float AdjustVolumeDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AdjustVolumeLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AAmbientSound::AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AmbientSound.AdjustVolume");
|
|
|
|
AAmbientSound_AdjustVolume_Params params;
|
|
params.AdjustVolumeDuration = AdjustVolumeDuration;
|
|
params.AdjustVolumeLevel = AdjustVolumeLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSequenceBase.GetPlayLength
|
|
// (RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimSequenceBase::GetPlayLength()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSequenceBase.GetPlayLength");
|
|
|
|
UAnimSequenceBase_GetPlayLength_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimNotifyState_Trail.OverridePSTemplate
|
|
// (Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* meshComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// class UAnimSequenceBase* Animation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UParticleSystem* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UParticleSystem* UAnimNotifyState_Trail::OverridePSTemplate(class USkeletalMeshComponent* meshComp, class UAnimSequenceBase* Animation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimNotifyState_Trail.OverridePSTemplate");
|
|
|
|
UAnimNotifyState_Trail_OverridePSTemplate_Params params;
|
|
params.meshComp = meshComp;
|
|
params.Animation = Animation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.StopAnim
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAnimSingleNodeInstance::StopAnim()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.StopAnim");
|
|
|
|
UAnimSingleNodeInstance_StopAnim_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetReverse
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInReverse (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetReverse(bool bInReverse)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetReverse");
|
|
|
|
UAnimSingleNodeInstance_SetReverse_Params params;
|
|
params.bInReverse = bInReverse;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetPreviewCurveOverride
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName PoseName (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRemoveIfZero (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetPreviewCurveOverride(const struct FName& PoseName, float Value, bool bRemoveIfZero)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetPreviewCurveOverride");
|
|
|
|
UAnimSingleNodeInstance_SetPreviewCurveOverride_Params params;
|
|
params.PoseName = PoseName;
|
|
params.Value = Value;
|
|
params.bRemoveIfZero = bRemoveIfZero;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetPositionWithPreviousTime
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPreviousTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFireNotifies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetPositionWithPreviousTime(float InPosition, float InPreviousTime, bool bFireNotifies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetPositionWithPreviousTime");
|
|
|
|
UAnimSingleNodeInstance_SetPositionWithPreviousTime_Params params;
|
|
params.InPosition = InPosition;
|
|
params.InPreviousTime = InPreviousTime;
|
|
params.bFireNotifies = bFireNotifies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetPosition
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFireNotifies (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetPosition(float InPosition, bool bFireNotifies)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetPosition");
|
|
|
|
UAnimSingleNodeInstance_SetPosition_Params params;
|
|
params.InPosition = InPosition;
|
|
params.bFireNotifies = bFireNotifies;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetPlayRate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetPlayRate(float InPlayRate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetPlayRate");
|
|
|
|
UAnimSingleNodeInstance_SetPlayRate_Params params;
|
|
params.InPlayRate = InPlayRate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetPlaying
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bIsPlaying (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetPlaying(bool bIsPlaying)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetPlaying");
|
|
|
|
UAnimSingleNodeInstance_SetPlaying_Params params;
|
|
params.bIsPlaying = bIsPlaying;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetLooping
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bIsLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetLooping(bool bIsLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetLooping");
|
|
|
|
UAnimSingleNodeInstance_SetLooping_Params params;
|
|
params.bIsLooping = bIsLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetBlendSpaceInput
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector InBlendInput (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetBlendSpaceInput(const struct FVector& InBlendInput)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetBlendSpaceInput");
|
|
|
|
UAnimSingleNodeInstance_SetBlendSpaceInput_Params params;
|
|
params.InBlendInput = InBlendInput;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.SetAnimationAsset
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UAnimationAsset* NewAsset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::SetAnimationAsset(class UAnimationAsset* NewAsset, bool bIsLooping, float InPlayRate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.SetAnimationAsset");
|
|
|
|
UAnimSingleNodeInstance_SetAnimationAsset_Params params;
|
|
params.NewAsset = NewAsset;
|
|
params.bIsLooping = bIsLooping;
|
|
params.InPlayRate = InPlayRate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.PlayAnim
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bIsLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPlayRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InStartPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAnimSingleNodeInstance::PlayAnim(bool bIsLooping, float InPlayRate, float InStartPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.PlayAnim");
|
|
|
|
UAnimSingleNodeInstance_PlayAnim_Params params;
|
|
params.bIsLooping = bIsLooping;
|
|
params.InPlayRate = InPlayRate;
|
|
params.InStartPosition = InStartPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.GetLength
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UAnimSingleNodeInstance::GetLength()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.GetLength");
|
|
|
|
UAnimSingleNodeInstance_GetLength_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AnimSingleNodeInstance.GetAnimationAsset
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UAnimationAsset* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAnimationAsset* UAnimSingleNodeInstance::GetAnimationAsset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AnimSingleNodeInstance.GetAnimationAsset");
|
|
|
|
UAnimSingleNodeInstance_GetAnimationAsset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ArrowComponent.SetArrowColor
|
|
// (Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewColor (Parm, IsPlainOldData)
|
|
|
|
void UArrowComponent::SetArrowColor(const struct FLinearColor& NewColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ArrowComponent.SetArrowColor");
|
|
|
|
UArrowComponent_SetArrowColor_Params params;
|
|
params.NewColor = NewColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AsyncActionLoadPrimaryAsset.AsyncLoadPrimaryAsset
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAsset (Parm)
|
|
// TArray<struct FName> LoadBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UAsyncActionLoadPrimaryAsset* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncActionLoadPrimaryAsset* UAsyncActionLoadPrimaryAsset::AsyncLoadPrimaryAsset(const struct FPrimaryAssetId& PrimaryAsset, TArray<struct FName> LoadBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AsyncActionLoadPrimaryAsset.AsyncLoadPrimaryAsset");
|
|
|
|
UAsyncActionLoadPrimaryAsset_AsyncLoadPrimaryAsset_Params params;
|
|
params.PrimaryAsset = PrimaryAsset;
|
|
params.LoadBundles = LoadBundles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AsyncActionLoadPrimaryAssetClass.AsyncLoadPrimaryAssetClass
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAsset (Parm)
|
|
// TArray<struct FName> LoadBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UAsyncActionLoadPrimaryAssetClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncActionLoadPrimaryAssetClass* UAsyncActionLoadPrimaryAssetClass::AsyncLoadPrimaryAssetClass(const struct FPrimaryAssetId& PrimaryAsset, TArray<struct FName> LoadBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AsyncActionLoadPrimaryAssetClass.AsyncLoadPrimaryAssetClass");
|
|
|
|
UAsyncActionLoadPrimaryAssetClass_AsyncLoadPrimaryAssetClass_Params params;
|
|
params.PrimaryAsset = PrimaryAsset;
|
|
params.LoadBundles = LoadBundles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AsyncActionLoadPrimaryAssetList.AsyncLoadPrimaryAssetList
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FPrimaryAssetId> PrimaryAssetList (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FName> LoadBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UAsyncActionLoadPrimaryAssetList* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncActionLoadPrimaryAssetList* UAsyncActionLoadPrimaryAssetList::AsyncLoadPrimaryAssetList(TArray<struct FPrimaryAssetId> PrimaryAssetList, TArray<struct FName> LoadBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AsyncActionLoadPrimaryAssetList.AsyncLoadPrimaryAssetList");
|
|
|
|
UAsyncActionLoadPrimaryAssetList_AsyncLoadPrimaryAssetList_Params params;
|
|
params.PrimaryAssetList = PrimaryAssetList;
|
|
params.LoadBundles = LoadBundles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AsyncActionLoadPrimaryAssetClassList.AsyncLoadPrimaryAssetClassList
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FPrimaryAssetId> PrimaryAssetList (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FName> LoadBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UAsyncActionLoadPrimaryAssetClassList* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncActionLoadPrimaryAssetClassList* UAsyncActionLoadPrimaryAssetClassList::AsyncLoadPrimaryAssetClassList(TArray<struct FPrimaryAssetId> PrimaryAssetList, TArray<struct FName> LoadBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AsyncActionLoadPrimaryAssetClassList.AsyncLoadPrimaryAssetClassList");
|
|
|
|
UAsyncActionLoadPrimaryAssetClassList_AsyncLoadPrimaryAssetClassList_Params params;
|
|
params.PrimaryAssetList = PrimaryAssetList;
|
|
params.LoadBundles = LoadBundles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AsyncActionChangePrimaryAssetBundles.AsyncChangeBundleStateForPrimaryAssetList
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FPrimaryAssetId> PrimaryAssetList (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FName> AddBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FName> RemoveBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UAsyncActionChangePrimaryAssetBundles* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncActionChangePrimaryAssetBundles* UAsyncActionChangePrimaryAssetBundles::AsyncChangeBundleStateForPrimaryAssetList(TArray<struct FPrimaryAssetId> PrimaryAssetList, TArray<struct FName> AddBundles, TArray<struct FName> RemoveBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AsyncActionChangePrimaryAssetBundles.AsyncChangeBundleStateForPrimaryAssetList");
|
|
|
|
UAsyncActionChangePrimaryAssetBundles_AsyncChangeBundleStateForPrimaryAssetList_Params params;
|
|
params.PrimaryAssetList = PrimaryAssetList;
|
|
params.AddBundles = AddBundles;
|
|
params.RemoveBundles = RemoveBundles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AsyncActionChangePrimaryAssetBundles.AsyncChangeBundleStateForMatchingPrimaryAssets
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FName> NewBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FName> OldBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UAsyncActionChangePrimaryAssetBundles* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UAsyncActionChangePrimaryAssetBundles* UAsyncActionChangePrimaryAssetBundles::AsyncChangeBundleStateForMatchingPrimaryAssets(TArray<struct FName> NewBundles, TArray<struct FName> OldBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AsyncActionChangePrimaryAssetBundles.AsyncChangeBundleStateForMatchingPrimaryAssets");
|
|
|
|
UAsyncActionChangePrimaryAssetBundles_AsyncChangeBundleStateForMatchingPrimaryAssets_Params params;
|
|
params.NewBundles = NewBundles;
|
|
params.OldBundles = OldBundles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.StartPrecompute
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UAtmosphericFogComponent::StartPrecompute()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.StartPrecompute");
|
|
|
|
UAtmosphericFogComponent_StartPrecompute_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetSunMultiplier
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewSunMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetSunMultiplier(float NewSunMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetSunMultiplier");
|
|
|
|
UAtmosphericFogComponent_SetSunMultiplier_Params params;
|
|
params.NewSunMultiplier = NewSunMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetStartDistance
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewStartDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetStartDistance(float NewStartDistance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetStartDistance");
|
|
|
|
UAtmosphericFogComponent_SetStartDistance_Params params;
|
|
params.NewStartDistance = NewStartDistance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetPrecomputeParams
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float DensityHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaxScatteringOrder (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int InscatterAltitudeSampleNum (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetPrecomputeParams(float DensityHeight, int MaxScatteringOrder, int InscatterAltitudeSampleNum)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetPrecomputeParams");
|
|
|
|
UAtmosphericFogComponent_SetPrecomputeParams_Params params;
|
|
params.DensityHeight = DensityHeight;
|
|
params.MaxScatteringOrder = MaxScatteringOrder;
|
|
params.InscatterAltitudeSampleNum = InscatterAltitudeSampleNum;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetFogMultiplier
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFogMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetFogMultiplier(float NewFogMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetFogMultiplier");
|
|
|
|
UAtmosphericFogComponent_SetFogMultiplier_Params params;
|
|
params.NewFogMultiplier = NewFogMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetDistanceScale
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewDistanceScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetDistanceScale(float NewDistanceScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetDistanceScale");
|
|
|
|
UAtmosphericFogComponent_SetDistanceScale_Params params;
|
|
params.NewDistanceScale = NewDistanceScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetDistanceOffset
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewDistanceOffset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetDistanceOffset(float NewDistanceOffset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetDistanceOffset");
|
|
|
|
UAtmosphericFogComponent_SetDistanceOffset_Params params;
|
|
params.NewDistanceOffset = NewDistanceOffset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetDensityOffset
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewDensityOffset (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetDensityOffset(float NewDensityOffset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetDensityOffset");
|
|
|
|
UAtmosphericFogComponent_SetDensityOffset_Params params;
|
|
params.NewDensityOffset = NewDensityOffset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetDensityMultiplier
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewDensityMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetDensityMultiplier(float NewDensityMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetDensityMultiplier");
|
|
|
|
UAtmosphericFogComponent_SetDensityMultiplier_Params params;
|
|
params.NewDensityMultiplier = NewDensityMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetDefaultLightColor
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewLightColor (Parm, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetDefaultLightColor(const struct FLinearColor& NewLightColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetDefaultLightColor");
|
|
|
|
UAtmosphericFogComponent_SetDefaultLightColor_Params params;
|
|
params.NewLightColor = NewLightColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetDefaultBrightness
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewBrightness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetDefaultBrightness(float NewBrightness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetDefaultBrightness");
|
|
|
|
UAtmosphericFogComponent_SetDefaultBrightness_Params params;
|
|
params.NewBrightness = NewBrightness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.SetAltitudeScale
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewAltitudeScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::SetAltitudeScale(float NewAltitudeScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.SetAltitudeScale");
|
|
|
|
UAtmosphericFogComponent_SetAltitudeScale_Params params;
|
|
params.NewAltitudeScale = NewAltitudeScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.DisableSunDisk
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewSunDisk (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::DisableSunDisk(bool NewSunDisk)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.DisableSunDisk");
|
|
|
|
UAtmosphericFogComponent_DisableSunDisk_Params params;
|
|
params.NewSunDisk = NewSunDisk;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AtmosphericFogComponent.DisableGroundScattering
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NewGroundScattering (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAtmosphericFogComponent::DisableGroundScattering(bool NewGroundScattering)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AtmosphericFogComponent.DisableGroundScattering");
|
|
|
|
UAtmosphericFogComponent_DisableGroundScattering_Params params;
|
|
params.NewGroundScattering = NewGroundScattering;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.Stop
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UAudioComponent::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.Stop");
|
|
|
|
UAudioComponent_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetWaveParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USoundWave* InWave (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetWaveParameter(const struct FName& InName, class USoundWave* InWave)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetWaveParameter");
|
|
|
|
UAudioComponent_SetWaveParameter_Params params;
|
|
params.InName = InName;
|
|
params.InWave = InWave;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetVolumeMultiplier
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewVolumeMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetVolumeMultiplier(float NewVolumeMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetVolumeMultiplier");
|
|
|
|
UAudioComponent_SetVolumeMultiplier_Params params;
|
|
params.NewVolumeMultiplier = NewVolumeMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetUISound
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInUISound (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetUISound(bool bInUISound)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetUISound");
|
|
|
|
UAudioComponent_SetUISound_Params params;
|
|
params.bInUISound = bInUISound;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetSubmixSend
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundSubmix* Submix (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float SendLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetSubmixSend(class USoundSubmix* Submix, float SendLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetSubmixSend");
|
|
|
|
UAudioComponent_SetSubmixSend_Params params;
|
|
params.Submix = Submix;
|
|
params.SendLevel = SendLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetSound
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USoundBase* NewSound (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetSound(class USoundBase* NewSound)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetSound");
|
|
|
|
UAudioComponent_SetSound_Params params;
|
|
params.NewSound = NewSound;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetPitchMultiplier
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewPitchMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetPitchMultiplier(float NewPitchMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetPitchMultiplier");
|
|
|
|
UAudioComponent_SetPitchMultiplier_Params params;
|
|
params.NewPitchMultiplier = NewPitchMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetPaused
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bPause (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetPaused(bool bPause)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetPaused");
|
|
|
|
UAudioComponent_SetPaused_Params params;
|
|
params.bPause = bPause;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetLowPassFilterFrequency
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InLowPassFilterFrequency (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetLowPassFilterFrequency(float InLowPassFilterFrequency)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetLowPassFilterFrequency");
|
|
|
|
UAudioComponent_SetLowPassFilterFrequency_Params params;
|
|
params.InLowPassFilterFrequency = InLowPassFilterFrequency;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetLowPassFilterEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InLowPassFilterEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetLowPassFilterEnabled(bool InLowPassFilterEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetLowPassFilterEnabled");
|
|
|
|
UAudioComponent_SetLowPassFilterEnabled_Params params;
|
|
params.InLowPassFilterEnabled = InLowPassFilterEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetIntParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetIntParameter(const struct FName& InName, int inInt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetIntParameter");
|
|
|
|
UAudioComponent_SetIntParameter_Params params;
|
|
params.InName = InName;
|
|
params.inInt = inInt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetFloatParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InFloat (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetFloatParameter(const struct FName& InName, float InFloat)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetFloatParameter");
|
|
|
|
UAudioComponent_SetFloatParameter_Params params;
|
|
params.InName = InName;
|
|
params.InFloat = InFloat;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.SetBoolParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::SetBoolParameter(const struct FName& InName, bool InBool)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.SetBoolParameter");
|
|
|
|
UAudioComponent_SetBoolParameter_Params params;
|
|
params.InName = InName;
|
|
params.InBool = InBool;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.Play
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::Play(float StartTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.Play");
|
|
|
|
UAudioComponent_Play_Params params;
|
|
params.StartTime = StartTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.IsPlaying
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAudioComponent::IsPlaying()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.IsPlaying");
|
|
|
|
UAudioComponent_IsPlaying_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.FadeOut
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FadeOutDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeVolumeLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::FadeOut(float FadeOutDuration, float FadeVolumeLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.FadeOut");
|
|
|
|
UAudioComponent_FadeOut_Params params;
|
|
params.FadeOutDuration = FadeOutDuration;
|
|
params.FadeVolumeLevel = FadeVolumeLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.FadeIn
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float FadeInDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float FadeVolumeLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::FadeIn(float FadeInDuration, float FadeVolumeLevel, float StartTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.FadeIn");
|
|
|
|
UAudioComponent_FadeIn_Params params;
|
|
params.FadeInDuration = FadeInDuration;
|
|
params.FadeVolumeLevel = FadeVolumeLevel;
|
|
params.StartTime = StartTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.BP_GetAttenuationSettingsToApply
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSoundAttenuationSettings OutAttenuationSettings (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAudioComponent::BP_GetAttenuationSettingsToApply(struct FSoundAttenuationSettings* OutAttenuationSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.BP_GetAttenuationSettingsToApply");
|
|
|
|
UAudioComponent_BP_GetAttenuationSettingsToApply_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutAttenuationSettings != nullptr)
|
|
*OutAttenuationSettings = params.OutAttenuationSettings;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.AdjustVolume
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float AdjustVolumeDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AdjustVolumeLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UAudioComponent::AdjustVolume(float AdjustVolumeDuration, float AdjustVolumeLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.AdjustVolume");
|
|
|
|
UAudioComponent_AdjustVolume_Params params;
|
|
params.AdjustVolumeDuration = AdjustVolumeDuration;
|
|
params.AdjustVolumeLevel = AdjustVolumeLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioComponent.AdjustAttenuation
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSoundAttenuationSettings InAttenuationSettings (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UAudioComponent::AdjustAttenuation(const struct FSoundAttenuationSettings& InAttenuationSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioComponent.AdjustAttenuation");
|
|
|
|
UAudioComponent_AdjustAttenuation_Params params;
|
|
params.InAttenuationSettings = InAttenuationSettings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioVolume.SetReverbSettings
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FReverbSettings NewReverbSettings (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void AAudioVolume::SetReverbSettings(const struct FReverbSettings& NewReverbSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioVolume.SetReverbSettings");
|
|
|
|
AAudioVolume_SetReverbSettings_Params params;
|
|
params.NewReverbSettings = NewReverbSettings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioVolume.SetPriority
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewPriority (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AAudioVolume::SetPriority(float NewPriority)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioVolume.SetPriority");
|
|
|
|
AAudioVolume_SetPriority_Params params;
|
|
params.NewPriority = NewPriority;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioVolume.SetInteriorSettings
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FInteriorSettings NewInteriorSettings (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void AAudioVolume::SetInteriorSettings(const struct FInteriorSettings& NewInteriorSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioVolume.SetInteriorSettings");
|
|
|
|
AAudioVolume_SetInteriorSettings_Params params;
|
|
params.NewInteriorSettings = NewInteriorSettings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioVolume.SetEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AAudioVolume::SetEnabled(bool bNewEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioVolume.SetEnabled");
|
|
|
|
AAudioVolume_SetEnabled_Params params;
|
|
params.bNewEnabled = bNewEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AudioVolume.OnRep_bEnabled
|
|
// (Final, Native, Private)
|
|
|
|
void AAudioVolume::OnRep_bEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AudioVolume.OnRep_bEnabled");
|
|
|
|
AAudioVolume_OnRep_bEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.AvoidanceManager.RegisterMovementComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMovementComponent* MovementComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// float AvoidanceWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UAvoidanceManager::RegisterMovementComponent(class UMovementComponent* MovementComp, float AvoidanceWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AvoidanceManager.RegisterMovementComponent");
|
|
|
|
UAvoidanceManager_RegisterMovementComponent_Params params;
|
|
params.MovementComp = MovementComp;
|
|
params.AvoidanceWeight = AvoidanceWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AvoidanceManager.GetObjectCount
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAvoidanceManager::GetObjectCount()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AvoidanceManager.GetObjectCount");
|
|
|
|
UAvoidanceManager_GetObjectCount_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AvoidanceManager.GetNewAvoidanceUID
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UAvoidanceManager::GetNewAvoidanceUID()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AvoidanceManager.GetNewAvoidanceUID");
|
|
|
|
UAvoidanceManager_GetNewAvoidanceUID_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.AvoidanceManager.GetAvoidanceVelocityForComponent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMovementComponent* MovementComp (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UAvoidanceManager::GetAvoidanceVelocityForComponent(class UMovementComponent* MovementComp)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.AvoidanceManager.GetAvoidanceVelocityForComponent");
|
|
|
|
UAvoidanceManager_GetAvoidanceVelocityForComponent_Params params;
|
|
params.MovementComp = MovementComp;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BillboardComponent.SetUV
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewU (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewUL (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewV (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewVL (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBillboardComponent::SetUV(int NewU, int NewUL, int NewV, int NewVL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BillboardComponent.SetUV");
|
|
|
|
UBillboardComponent_SetUV_Params params;
|
|
params.NewU = NewU;
|
|
params.NewUL = NewUL;
|
|
params.NewV = NewV;
|
|
params.NewVL = NewVL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BillboardComponent.SetSpriteAndUV
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture2D* NewSprite (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewU (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewUL (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewV (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NewVL (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBillboardComponent::SetSpriteAndUV(class UTexture2D* NewSprite, int NewU, int NewUL, int NewV, int NewVL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BillboardComponent.SetSpriteAndUV");
|
|
|
|
UBillboardComponent_SetSpriteAndUV_Params params;
|
|
params.NewSprite = NewSprite;
|
|
params.NewU = NewU;
|
|
params.NewUL = NewUL;
|
|
params.NewV = NewV;
|
|
params.NewVL = NewVL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BillboardComponent.SetSprite
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture2D* NewSprite (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBillboardComponent::SetSprite(class UTexture2D* NewSprite)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BillboardComponent.SetSprite");
|
|
|
|
UBillboardComponent_SetSprite_Params params;
|
|
params.NewSprite = NewSprite;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.SetMapPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TMap<int, int> Value (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UBlueprintMapLibrary::SetMapPropertyByName(class UObject* Object, const struct FName& PropertyName, TMap<int, int> Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.SetMapPropertyByName");
|
|
|
|
UBlueprintMapLibrary_SetMapPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Values
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<int> Values (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UBlueprintMapLibrary::Map_Values(TMap<int, int> TargetMap, TArray<int>* Values)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Values");
|
|
|
|
UBlueprintMapLibrary_Map_Values_Params params;
|
|
params.TargetMap = TargetMap;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Values != nullptr)
|
|
*Values = params.Values;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Remove
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Key (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UBlueprintMapLibrary::Map_Remove(TMap<int, int> TargetMap, int Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Remove");
|
|
|
|
UBlueprintMapLibrary_Map_Remove_Params params;
|
|
params.TargetMap = TargetMap;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Length
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UBlueprintMapLibrary::Map_Length(TMap<int, int> TargetMap)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Length");
|
|
|
|
UBlueprintMapLibrary_Map_Length_Params params;
|
|
params.TargetMap = TargetMap;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Keys
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<int> Keys (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UBlueprintMapLibrary::Map_Keys(TMap<int, int> TargetMap, TArray<int>* Keys)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Keys");
|
|
|
|
UBlueprintMapLibrary_Map_Keys_Params params;
|
|
params.TargetMap = TargetMap;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Keys != nullptr)
|
|
*Keys = params.Keys;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Find
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Key (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// int Value (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UBlueprintMapLibrary::Map_Find(TMap<int, int> TargetMap, int Key, int* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Find");
|
|
|
|
UBlueprintMapLibrary_Map_Find_Params params;
|
|
params.TargetMap = TargetMap;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Value != nullptr)
|
|
*Value = params.Value;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Contains
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Key (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UBlueprintMapLibrary::Map_Contains(TMap<int, int> TargetMap, int Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Contains");
|
|
|
|
UBlueprintMapLibrary_Map_Contains_Params params;
|
|
params.TargetMap = TargetMap;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Clear
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UBlueprintMapLibrary::Map_Clear(TMap<int, int> TargetMap)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Clear");
|
|
|
|
UBlueprintMapLibrary_Map_Clear_Params params;
|
|
params.TargetMap = TargetMap;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintMapLibrary.Map_Add
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TMap<int, int> TargetMap (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Key (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// int Value (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
|
|
void UBlueprintMapLibrary::Map_Add(TMap<int, int> TargetMap, int Key, int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintMapLibrary.Map_Add");
|
|
|
|
UBlueprintMapLibrary_Map_Add_Params params;
|
|
params.TargetMap = TargetMap;
|
|
params.Key = Key;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationFromNow
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int inSecondsFromNow (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText Title (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText Body (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText Action (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString ActivationEvent (Parm, ZeroConstructor)
|
|
|
|
void UBlueprintPlatformLibrary::ScheduleLocalNotificationFromNow(int inSecondsFromNow, const struct FText& Title, const struct FText& Body, const struct FText& Action, const struct FString& ActivationEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationFromNow");
|
|
|
|
UBlueprintPlatformLibrary_ScheduleLocalNotificationFromNow_Params params;
|
|
params.inSecondsFromNow = inSecondsFromNow;
|
|
params.Title = Title;
|
|
params.Body = Body;
|
|
params.Action = Action;
|
|
params.ActivationEvent = ActivationEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationBadgeFromNow
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int inSecondsFromNow (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ActivationEvent (Parm, ZeroConstructor)
|
|
|
|
void UBlueprintPlatformLibrary::ScheduleLocalNotificationBadgeFromNow(int inSecondsFromNow, const struct FString& ActivationEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationBadgeFromNow");
|
|
|
|
UBlueprintPlatformLibrary_ScheduleLocalNotificationBadgeFromNow_Params params;
|
|
params.inSecondsFromNow = inSecondsFromNow;
|
|
params.ActivationEvent = ActivationEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationBadgeAtTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FDateTime FireDateTime (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool LocalTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ActivationEvent (Parm, ZeroConstructor)
|
|
|
|
void UBlueprintPlatformLibrary::ScheduleLocalNotificationBadgeAtTime(const struct FDateTime& FireDateTime, bool LocalTime, const struct FString& ActivationEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationBadgeAtTime");
|
|
|
|
UBlueprintPlatformLibrary_ScheduleLocalNotificationBadgeAtTime_Params params;
|
|
params.FireDateTime = FireDateTime;
|
|
params.LocalTime = LocalTime;
|
|
params.ActivationEvent = ActivationEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationAtTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FDateTime FireDateTime (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool LocalTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText Title (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText Body (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText Action (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString ActivationEvent (Parm, ZeroConstructor)
|
|
|
|
void UBlueprintPlatformLibrary::ScheduleLocalNotificationAtTime(const struct FDateTime& FireDateTime, bool LocalTime, const struct FText& Title, const struct FText& Body, const struct FText& Action, const struct FString& ActivationEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.ScheduleLocalNotificationAtTime");
|
|
|
|
UBlueprintPlatformLibrary_ScheduleLocalNotificationAtTime_Params params;
|
|
params.FireDateTime = FireDateTime;
|
|
params.LocalTime = LocalTime;
|
|
params.Title = Title;
|
|
params.Body = Body;
|
|
params.Action = Action;
|
|
params.ActivationEvent = ActivationEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.GetLaunchNotification
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// bool NotificationLaunchedApp (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ActivationEvent (Parm, OutParm, ZeroConstructor)
|
|
// int FireDate (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBlueprintPlatformLibrary::GetLaunchNotification(bool* NotificationLaunchedApp, struct FString* ActivationEvent, int* FireDate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.GetLaunchNotification");
|
|
|
|
UBlueprintPlatformLibrary_GetLaunchNotification_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (NotificationLaunchedApp != nullptr)
|
|
*NotificationLaunchedApp = params.NotificationLaunchedApp;
|
|
if (ActivationEvent != nullptr)
|
|
*ActivationEvent = params.ActivationEvent;
|
|
if (FireDate != nullptr)
|
|
*FireDate = params.FireDate;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.ClearAllLocalNotifications
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UBlueprintPlatformLibrary::ClearAllLocalNotifications()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.ClearAllLocalNotifications");
|
|
|
|
UBlueprintPlatformLibrary_ClearAllLocalNotifications_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintPlatformLibrary.CancelLocalNotification
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString ActivationEvent (Parm, ZeroConstructor)
|
|
|
|
void UBlueprintPlatformLibrary::CancelLocalNotification(const struct FString& ActivationEvent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintPlatformLibrary.CancelLocalNotification");
|
|
|
|
UBlueprintPlatformLibrary_CancelLocalNotification_Params params;
|
|
params.ActivationEvent = ActivationEvent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.SetSetPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UBlueprintSetLibrary::SetSetPropertyByName(class UObject* Object, const struct FName& PropertyName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.SetSetPropertyByName");
|
|
|
|
UBlueprintSetLibrary_SetSetPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Union
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
|
|
void UBlueprintSetLibrary::Set_Union()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Union");
|
|
|
|
UBlueprintSetLibrary_Set_Union_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_ToArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> Result (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UBlueprintSetLibrary::Set_ToArray(TArray<int>* Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_ToArray");
|
|
|
|
UBlueprintSetLibrary_Set_ToArray_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Result != nullptr)
|
|
*Result = params.Result;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_RemoveItems
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> items (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UBlueprintSetLibrary::Set_RemoveItems(TArray<int> items)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_RemoveItems");
|
|
|
|
UBlueprintSetLibrary_Set_RemoveItems_Params params;
|
|
params.items = items;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Remove
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int Item (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UBlueprintSetLibrary::Set_Remove(int Item)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Remove");
|
|
|
|
UBlueprintSetLibrary_Set_Remove_Params params;
|
|
params.Item = Item;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Length
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UBlueprintSetLibrary::Set_Length()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Length");
|
|
|
|
UBlueprintSetLibrary_Set_Length_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Intersection
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
|
|
void UBlueprintSetLibrary::Set_Intersection()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Intersection");
|
|
|
|
UBlueprintSetLibrary_Set_Intersection_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Difference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
|
|
void UBlueprintSetLibrary::Set_Difference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Difference");
|
|
|
|
UBlueprintSetLibrary_Set_Difference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Contains
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ItemToFind (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UBlueprintSetLibrary::Set_Contains(int ItemToFind)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Contains");
|
|
|
|
UBlueprintSetLibrary_Set_Contains_Params params;
|
|
params.ItemToFind = ItemToFind;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Clear
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
|
|
void UBlueprintSetLibrary::Set_Clear()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Clear");
|
|
|
|
UBlueprintSetLibrary_Set_Clear_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_AddItems
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> NewItems (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UBlueprintSetLibrary::Set_AddItems(TArray<int> NewItems)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_AddItems");
|
|
|
|
UBlueprintSetLibrary_Set_AddItems_Params params;
|
|
params.NewItems = NewItems;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.BlueprintSetLibrary.Set_Add
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewItem (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
|
|
void UBlueprintSetLibrary::Set_Add(int NewItem)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.BlueprintSetLibrary.Set_Add");
|
|
|
|
UBlueprintSetLibrary_Set_Add_Params params;
|
|
params.NewItem = NewItem;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraAnimInst.Stop
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bImmediate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraAnimInst::Stop(bool bImmediate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraAnimInst.Stop");
|
|
|
|
UCameraAnimInst_Stop_Params params;
|
|
params.bImmediate = bImmediate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraAnimInst.SetScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraAnimInst::SetScale(float NewDuration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraAnimInst.SetScale");
|
|
|
|
UCameraAnimInst_SetScale_Params params;
|
|
params.NewDuration = NewDuration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraAnimInst.SetDuration
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewDuration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraAnimInst::SetDuration(float NewDuration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraAnimInst.SetDuration");
|
|
|
|
UCameraAnimInst_SetDuration_Params params;
|
|
params.NewDuration = NewDuration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraModifier.IsDisabled
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UCameraModifier::IsDisabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraModifier.IsDisabled");
|
|
|
|
UCameraModifier_IsDisabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraModifier.GetViewTarget
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* UCameraModifier::GetViewTarget()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraModifier.GetViewTarget");
|
|
|
|
UCameraModifier_GetViewTarget_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraModifier.EnableModifier
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UCameraModifier::EnableModifier()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraModifier.EnableModifier");
|
|
|
|
UCameraModifier_EnableModifier_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraModifier.DisableModifier
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bImmediate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraModifier::DisableModifier(bool bImmediate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraModifier.DisableModifier");
|
|
|
|
UCameraModifier_DisableModifier_Params params;
|
|
params.bImmediate = bImmediate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraModifier.BlueprintModifyPostProcess
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PostProcessBlendWeight (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPostProcessSettings PostProcessSettings (Parm, OutParm)
|
|
|
|
void UCameraModifier::BlueprintModifyPostProcess(float DeltaTime, float* PostProcessBlendWeight, struct FPostProcessSettings* PostProcessSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraModifier.BlueprintModifyPostProcess");
|
|
|
|
UCameraModifier_BlueprintModifyPostProcess_Params params;
|
|
params.DeltaTime = DeltaTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PostProcessBlendWeight != nullptr)
|
|
*PostProcessBlendWeight = params.PostProcessBlendWeight;
|
|
if (PostProcessSettings != nullptr)
|
|
*PostProcessSettings = params.PostProcessSettings;
|
|
}
|
|
|
|
|
|
// Function Engine.CameraModifier.BlueprintModifyCamera
|
|
// (BlueprintCosmetic, Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ViewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator ViewRotation (Parm, IsPlainOldData)
|
|
// float FOV (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NewViewLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator NewViewRotation (Parm, OutParm, IsPlainOldData)
|
|
// float NewFOV (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCameraModifier::BlueprintModifyCamera(float DeltaTime, const struct FVector& ViewLocation, const struct FRotator& ViewRotation, float FOV, struct FVector* NewViewLocation, struct FRotator* NewViewRotation, float* NewFOV)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CameraModifier.BlueprintModifyCamera");
|
|
|
|
UCameraModifier_BlueprintModifyCamera_Params params;
|
|
params.DeltaTime = DeltaTime;
|
|
params.ViewLocation = ViewLocation;
|
|
params.ViewRotation = ViewRotation;
|
|
params.FOV = FOV;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (NewViewLocation != nullptr)
|
|
*NewViewLocation = params.NewViewLocation;
|
|
if (NewViewRotation != nullptr)
|
|
*NewViewRotation = params.NewViewRotation;
|
|
if (NewFOV != nullptr)
|
|
*NewFOV = params.NewFOV;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_TextSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UFont* RenderFont (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString RenderText (Parm, ZeroConstructor)
|
|
// struct FVector2D Scale (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UCanvas::K2_TextSize(class UFont* RenderFont, const struct FString& RenderText, const struct FVector2D& Scale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_TextSize");
|
|
|
|
UCanvas_K2_TextSize_Params params;
|
|
params.RenderFont = RenderFont;
|
|
params.RenderText = RenderText;
|
|
params.Scale = Scale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_StrLen
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UFont* RenderFont (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString RenderText (Parm, ZeroConstructor)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UCanvas::K2_StrLen(class UFont* RenderFont, const struct FString& RenderText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_StrLen");
|
|
|
|
UCanvas_K2_StrLen_Params params;
|
|
params.RenderFont = RenderFont;
|
|
params.RenderText = RenderText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_Project
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UCanvas::K2_Project(const struct FVector& WorldLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_Project");
|
|
|
|
UCanvas_K2_Project_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawTriangle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* RenderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FCanvasUVTri> Triangles (Parm, ZeroConstructor)
|
|
|
|
void UCanvas::K2_DrawTriangle(class UTexture* RenderTexture, TArray<struct FCanvasUVTri> Triangles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawTriangle");
|
|
|
|
UCanvas_K2_DrawTriangle_Params params;
|
|
params.RenderTexture = RenderTexture;
|
|
params.Triangles = Triangles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawTexture
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* RenderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenSize (Parm, IsPlainOldData)
|
|
// struct FVector2D CoordinatePosition (Parm, IsPlainOldData)
|
|
// struct FVector2D CoordinateSize (Parm, IsPlainOldData)
|
|
// struct FLinearColor RenderColor (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EBlendMode> BlendMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Rotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D PivotPoint (Parm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawTexture(class UTexture* RenderTexture, const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, const struct FVector2D& CoordinatePosition, const struct FVector2D& CoordinateSize, const struct FLinearColor& RenderColor, TEnumAsByte<EBlendMode> BlendMode, float Rotation, const struct FVector2D& PivotPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawTexture");
|
|
|
|
UCanvas_K2_DrawTexture_Params params;
|
|
params.RenderTexture = RenderTexture;
|
|
params.ScreenPosition = ScreenPosition;
|
|
params.ScreenSize = ScreenSize;
|
|
params.CoordinatePosition = CoordinatePosition;
|
|
params.CoordinateSize = CoordinateSize;
|
|
params.RenderColor = RenderColor;
|
|
params.BlendMode = BlendMode;
|
|
params.Rotation = Rotation;
|
|
params.PivotPoint = PivotPoint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawText
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UFont* RenderFont (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString RenderText (Parm, ZeroConstructor)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FLinearColor RenderColor (Parm, IsPlainOldData)
|
|
// float Kerning (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ShadowColor (Parm, IsPlainOldData)
|
|
// struct FVector2D ShadowOffset (Parm, IsPlainOldData)
|
|
// bool bCentreX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bCentreY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bOutlined (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor OutlineColor (Parm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawText(class UFont* RenderFont, const struct FString& RenderText, const struct FVector2D& ScreenPosition, const struct FLinearColor& RenderColor, float Kerning, const struct FLinearColor& ShadowColor, const struct FVector2D& ShadowOffset, bool bCentreX, bool bCentreY, bool bOutlined, const struct FLinearColor& OutlineColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawText");
|
|
|
|
UCanvas_K2_DrawText_Params params;
|
|
params.RenderFont = RenderFont;
|
|
params.RenderText = RenderText;
|
|
params.ScreenPosition = ScreenPosition;
|
|
params.RenderColor = RenderColor;
|
|
params.Kerning = Kerning;
|
|
params.ShadowColor = ShadowColor;
|
|
params.ShadowOffset = ShadowOffset;
|
|
params.bCentreX = bCentreX;
|
|
params.bCentreY = bCentreY;
|
|
params.bOutlined = bOutlined;
|
|
params.OutlineColor = OutlineColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawPolygon
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* RenderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D Radius (Parm, IsPlainOldData)
|
|
// int NumberOfSides (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor RenderColor (Parm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawPolygon(class UTexture* RenderTexture, const struct FVector2D& ScreenPosition, const struct FVector2D& Radius, int NumberOfSides, const struct FLinearColor& RenderColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawPolygon");
|
|
|
|
UCanvas_K2_DrawPolygon_Params params;
|
|
params.RenderTexture = RenderTexture;
|
|
params.ScreenPosition = ScreenPosition;
|
|
params.Radius = Radius;
|
|
params.NumberOfSides = NumberOfSides;
|
|
params.RenderColor = RenderColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawMaterialTriangle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* RenderMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FCanvasUVTri> Triangles (Parm, ZeroConstructor)
|
|
|
|
void UCanvas::K2_DrawMaterialTriangle(class UMaterialInterface* RenderMaterial, TArray<struct FCanvasUVTri> Triangles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawMaterialTriangle");
|
|
|
|
UCanvas_K2_DrawMaterialTriangle_Params params;
|
|
params.RenderMaterial = RenderMaterial;
|
|
params.Triangles = Triangles;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawMaterial
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* RenderMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenSize (Parm, IsPlainOldData)
|
|
// struct FVector2D CoordinatePosition (Parm, IsPlainOldData)
|
|
// struct FVector2D CoordinateSize (Parm, IsPlainOldData)
|
|
// float Rotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D PivotPoint (Parm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawMaterial(class UMaterialInterface* RenderMaterial, const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, const struct FVector2D& CoordinatePosition, const struct FVector2D& CoordinateSize, float Rotation, const struct FVector2D& PivotPoint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawMaterial");
|
|
|
|
UCanvas_K2_DrawMaterial_Params params;
|
|
params.RenderMaterial = RenderMaterial;
|
|
params.ScreenPosition = ScreenPosition;
|
|
params.ScreenSize = ScreenSize;
|
|
params.CoordinatePosition = CoordinatePosition;
|
|
params.CoordinateSize = CoordinateSize;
|
|
params.Rotation = Rotation;
|
|
params.PivotPoint = PivotPoint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawLine
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D ScreenPositionA (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenPositionB (Parm, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor RenderColor (Parm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawLine(const struct FVector2D& ScreenPositionA, const struct FVector2D& ScreenPositionB, float Thickness, const struct FLinearColor& RenderColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawLine");
|
|
|
|
UCanvas_K2_DrawLine_Params params;
|
|
params.ScreenPositionA = ScreenPositionA;
|
|
params.ScreenPositionB = ScreenPositionB;
|
|
params.Thickness = Thickness;
|
|
params.RenderColor = RenderColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawBox
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenSize (Parm, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawBox(const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawBox");
|
|
|
|
UCanvas_K2_DrawBox_Params params;
|
|
params.ScreenPosition = ScreenPosition;
|
|
params.ScreenSize = ScreenSize;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_DrawBorder
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* BorderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* BackgroundTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* LeftBorderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* RightBorderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* TopBorderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* BottomBorderTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector2D ScreenSize (Parm, IsPlainOldData)
|
|
// struct FVector2D CoordinatePosition (Parm, IsPlainOldData)
|
|
// struct FVector2D CoordinateSize (Parm, IsPlainOldData)
|
|
// struct FLinearColor RenderColor (Parm, IsPlainOldData)
|
|
// struct FVector2D BorderScale (Parm, IsPlainOldData)
|
|
// struct FVector2D BackgroundScale (Parm, IsPlainOldData)
|
|
// float Rotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D PivotPoint (Parm, IsPlainOldData)
|
|
// struct FVector2D CornerSize (Parm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_DrawBorder(class UTexture* BorderTexture, class UTexture* BackgroundTexture, class UTexture* LeftBorderTexture, class UTexture* RightBorderTexture, class UTexture* TopBorderTexture, class UTexture* BottomBorderTexture, const struct FVector2D& ScreenPosition, const struct FVector2D& ScreenSize, const struct FVector2D& CoordinatePosition, const struct FVector2D& CoordinateSize, const struct FLinearColor& RenderColor, const struct FVector2D& BorderScale, const struct FVector2D& BackgroundScale, float Rotation, const struct FVector2D& PivotPoint, const struct FVector2D& CornerSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_DrawBorder");
|
|
|
|
UCanvas_K2_DrawBorder_Params params;
|
|
params.BorderTexture = BorderTexture;
|
|
params.BackgroundTexture = BackgroundTexture;
|
|
params.LeftBorderTexture = LeftBorderTexture;
|
|
params.RightBorderTexture = RightBorderTexture;
|
|
params.TopBorderTexture = TopBorderTexture;
|
|
params.BottomBorderTexture = BottomBorderTexture;
|
|
params.ScreenPosition = ScreenPosition;
|
|
params.ScreenSize = ScreenSize;
|
|
params.CoordinatePosition = CoordinatePosition;
|
|
params.CoordinateSize = CoordinateSize;
|
|
params.RenderColor = RenderColor;
|
|
params.BorderScale = BorderScale;
|
|
params.BackgroundScale = BackgroundScale;
|
|
params.Rotation = Rotation;
|
|
params.PivotPoint = PivotPoint;
|
|
params.CornerSize = CornerSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Canvas.K2_Deproject
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D ScreenPosition (Parm, IsPlainOldData)
|
|
// struct FVector WorldOrigin (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector WorldDirection (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UCanvas::K2_Deproject(const struct FVector2D& ScreenPosition, struct FVector* WorldOrigin, struct FVector* WorldDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Canvas.K2_Deproject");
|
|
|
|
UCanvas_K2_Deproject_Params params;
|
|
params.ScreenPosition = ScreenPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (WorldOrigin != nullptr)
|
|
*WorldOrigin = params.WorldOrigin;
|
|
if (WorldDirection != nullptr)
|
|
*WorldDirection = params.WorldDirection;
|
|
}
|
|
|
|
|
|
// Function Engine.CanvasRenderTarget2D.UpdateResource
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UCanvasRenderTarget2D::UpdateResource()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CanvasRenderTarget2D.UpdateResource");
|
|
|
|
UCanvasRenderTarget2D_UpdateResource_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CanvasRenderTarget2D.ReceiveUpdate
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class UCanvas* Canvas (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCanvasRenderTarget2D::ReceiveUpdate(class UCanvas* Canvas, int Width, int Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CanvasRenderTarget2D.ReceiveUpdate");
|
|
|
|
UCanvasRenderTarget2D_ReceiveUpdate_Params params;
|
|
params.Canvas = Canvas;
|
|
params.Width = Width;
|
|
params.Height = Height;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CanvasRenderTarget2D.GetSize
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Width (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Height (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCanvasRenderTarget2D::GetSize(int* Width, int* Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CanvasRenderTarget2D.GetSize");
|
|
|
|
UCanvasRenderTarget2D_GetSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Width != nullptr)
|
|
*Width = params.Width;
|
|
if (Height != nullptr)
|
|
*Height = params.Height;
|
|
}
|
|
|
|
|
|
// Function Engine.CanvasRenderTarget2D.CreateCanvasRenderTarget2D
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* CanvasRenderTarget2DClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCanvasRenderTarget2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UCanvasRenderTarget2D* UCanvasRenderTarget2D::CreateCanvasRenderTarget2D(class UObject* WorldContextObject, class UClass* CanvasRenderTarget2DClass, int Width, int Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CanvasRenderTarget2D.CreateCanvasRenderTarget2D");
|
|
|
|
UCanvasRenderTarget2D_CreateCanvasRenderTarget2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.CanvasRenderTarget2DClass = CanvasRenderTarget2DClass;
|
|
params.Width = Width;
|
|
params.Height = Height;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.SetCapsuleSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InHalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateOverlaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::SetCapsuleSize(float InRadius, float InHalfHeight, bool bUpdateOverlaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.SetCapsuleSize");
|
|
|
|
UCapsuleComponent_SetCapsuleSize_Params params;
|
|
params.InRadius = InRadius;
|
|
params.InHalfHeight = InHalfHeight;
|
|
params.bUpdateOverlaps = bUpdateOverlaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.SetCapsuleRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateOverlaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::SetCapsuleRadius(float Radius, bool bUpdateOverlaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.SetCapsuleRadius");
|
|
|
|
UCapsuleComponent_SetCapsuleRadius_Params params;
|
|
params.Radius = Radius;
|
|
params.bUpdateOverlaps = bUpdateOverlaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.SetCapsuleHalfHeight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateOverlaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::SetCapsuleHalfHeight(float HalfHeight, bool bUpdateOverlaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.SetCapsuleHalfHeight");
|
|
|
|
UCapsuleComponent_SetCapsuleHalfHeight_Params params;
|
|
params.HalfHeight = HalfHeight;
|
|
params.bUpdateOverlaps = bUpdateOverlaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetUnscaledCapsuleSize_WithoutHemisphere
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float OutRadius (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutHalfHeightWithoutHemisphere (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::GetUnscaledCapsuleSize_WithoutHemisphere(float* OutRadius, float* OutHalfHeightWithoutHemisphere)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetUnscaledCapsuleSize_WithoutHemisphere");
|
|
|
|
UCapsuleComponent_GetUnscaledCapsuleSize_WithoutHemisphere_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRadius != nullptr)
|
|
*OutRadius = params.OutRadius;
|
|
if (OutHalfHeightWithoutHemisphere != nullptr)
|
|
*OutHalfHeightWithoutHemisphere = params.OutHalfHeightWithoutHemisphere;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetUnscaledCapsuleSize
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float OutRadius (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutHalfHeight (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::GetUnscaledCapsuleSize(float* OutRadius, float* OutHalfHeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetUnscaledCapsuleSize");
|
|
|
|
UCapsuleComponent_GetUnscaledCapsuleSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRadius != nullptr)
|
|
*OutRadius = params.OutRadius;
|
|
if (OutHalfHeight != nullptr)
|
|
*OutHalfHeight = params.OutHalfHeight;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetUnscaledCapsuleRadius
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetUnscaledCapsuleRadius()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetUnscaledCapsuleRadius");
|
|
|
|
UCapsuleComponent_GetUnscaledCapsuleRadius_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetUnscaledCapsuleHalfHeight_WithoutHemisphere
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetUnscaledCapsuleHalfHeight_WithoutHemisphere()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetUnscaledCapsuleHalfHeight_WithoutHemisphere");
|
|
|
|
UCapsuleComponent_GetUnscaledCapsuleHalfHeight_WithoutHemisphere_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetUnscaledCapsuleHalfHeight
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetUnscaledCapsuleHalfHeight()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetUnscaledCapsuleHalfHeight");
|
|
|
|
UCapsuleComponent_GetUnscaledCapsuleHalfHeight_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetShapeScale
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetShapeScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetShapeScale");
|
|
|
|
UCapsuleComponent_GetShapeScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetScaledCapsuleSize_WithoutHemisphere
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float OutRadius (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutHalfHeightWithoutHemisphere (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::GetScaledCapsuleSize_WithoutHemisphere(float* OutRadius, float* OutHalfHeightWithoutHemisphere)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetScaledCapsuleSize_WithoutHemisphere");
|
|
|
|
UCapsuleComponent_GetScaledCapsuleSize_WithoutHemisphere_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRadius != nullptr)
|
|
*OutRadius = params.OutRadius;
|
|
if (OutHalfHeightWithoutHemisphere != nullptr)
|
|
*OutHalfHeightWithoutHemisphere = params.OutHalfHeightWithoutHemisphere;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetScaledCapsuleSize
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float OutRadius (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutHalfHeight (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCapsuleComponent::GetScaledCapsuleSize(float* OutRadius, float* OutHalfHeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetScaledCapsuleSize");
|
|
|
|
UCapsuleComponent_GetScaledCapsuleSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRadius != nullptr)
|
|
*OutRadius = params.OutRadius;
|
|
if (OutHalfHeight != nullptr)
|
|
*OutHalfHeight = params.OutHalfHeight;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetScaledCapsuleRadius
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetScaledCapsuleRadius()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetScaledCapsuleRadius");
|
|
|
|
UCapsuleComponent_GetScaledCapsuleRadius_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetScaledCapsuleHalfHeight_WithoutHemisphere
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetScaledCapsuleHalfHeight_WithoutHemisphere()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetScaledCapsuleHalfHeight_WithoutHemisphere");
|
|
|
|
UCapsuleComponent_GetScaledCapsuleHalfHeight_WithoutHemisphere_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CapsuleComponent.GetScaledCapsuleHalfHeight
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCapsuleComponent::GetScaledCapsuleHalfHeight()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CapsuleComponent.GetScaledCapsuleHalfHeight");
|
|
|
|
UCapsuleComponent_GetScaledCapsuleHalfHeight_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ChildActorComponent.SetChildActorClass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* InClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UChildActorComponent::SetChildActorClass(class UClass* InClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ChildActorComponent.SetChildActorClass");
|
|
|
|
UChildActorComponent_SetChildActorClass_Params params;
|
|
params.InClass = InClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameViewportClient.SSSwapControllers
|
|
// (Exec, Native, Public)
|
|
|
|
void UGameViewportClient::SSSwapControllers()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameViewportClient.SSSwapControllers");
|
|
|
|
UGameViewportClient_SSSwapControllers_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameViewportClient.ShowTitleSafeArea
|
|
// (Exec, Native, Public)
|
|
|
|
void UGameViewportClient::ShowTitleSafeArea()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameViewportClient.ShowTitleSafeArea");
|
|
|
|
UGameViewportClient_ShowTitleSafeArea_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameViewportClient.SetConsoleTarget
|
|
// (Exec, Native, Public)
|
|
// Parameters:
|
|
// int PlayerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameViewportClient::SetConsoleTarget(int PlayerIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameViewportClient.SetConsoleTarget");
|
|
|
|
UGameViewportClient_SetConsoleTarget_Params params;
|
|
params.PlayerIndex = PlayerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveBase.GetValueRange
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float MinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCurveBase::GetValueRange(float* MinValue, float* MaxValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveBase.GetValueRange");
|
|
|
|
UCurveBase_GetValueRange_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (MinValue != nullptr)
|
|
*MinValue = params.MinValue;
|
|
if (MaxValue != nullptr)
|
|
*MaxValue = params.MaxValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveBase.GetTimeRange
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float MinTime (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxTime (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UCurveBase::GetTimeRange(float* MinTime, float* MaxTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveBase.GetTimeRange");
|
|
|
|
UCurveBase_GetTimeRange_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (MinTime != nullptr)
|
|
*MinTime = params.MinTime;
|
|
if (MaxTime != nullptr)
|
|
*MaxTime = params.MaxTime;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveFloat.GetFloatValue
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCurveFloat::GetFloatValue(float InTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveFloat.GetFloatValue");
|
|
|
|
UCurveFloat_GetFloatValue_Params params;
|
|
params.InTime = InTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveLinearColor.GetLinearColorValue
|
|
// (Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UCurveLinearColor::GetLinearColorValue(float InTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveLinearColor.GetLinearColorValue");
|
|
|
|
UCurveLinearColor_GetLinearColorValue_Params params;
|
|
params.InTime = InTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveSourceInterface.GetCurveValue
|
|
// (Native, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// struct FName CurveName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UCurveSourceInterface::GetCurveValue(const struct FName& CurveName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveSourceInterface.GetCurveValue");
|
|
|
|
UCurveSourceInterface_GetCurveValue_Params params;
|
|
params.CurveName = CurveName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveSourceInterface.GetCurves
|
|
// (Native, Event, Public, HasOutParms, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// TArray<struct FNamedCurveValue> OutValues (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UCurveSourceInterface::GetCurves(TArray<struct FNamedCurveValue>* OutValues)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveSourceInterface.GetCurves");
|
|
|
|
UCurveSourceInterface_GetCurves_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutValues != nullptr)
|
|
*OutValues = params.OutValues;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveSourceInterface.GetBindingName
|
|
// (Native, Event, Public, BlueprintEvent, Const)
|
|
// Parameters:
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UCurveSourceInterface::GetBindingName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveSourceInterface.GetBindingName");
|
|
|
|
UCurveSourceInterface_GetBindingName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.CurveVector.GetVectorValue
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float InTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UCurveVector::GetVectorValue(float InTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.CurveVector.GetVectorValue");
|
|
|
|
UCurveVector_GetVectorValue_Params params;
|
|
params.InTime = InTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DataTableFunctionLibrary.GetDataTableRowNames
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UDataTable* Table (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FName> OutRowNames (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UDataTableFunctionLibrary::GetDataTableRowNames(class UDataTable* Table, TArray<struct FName>* OutRowNames)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DataTableFunctionLibrary.GetDataTableRowNames");
|
|
|
|
UDataTableFunctionLibrary_GetDataTableRowNames_Params params;
|
|
params.Table = Table;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRowNames != nullptr)
|
|
*OutRowNames = params.OutRowNames;
|
|
}
|
|
|
|
|
|
// Function Engine.DataTableFunctionLibrary.GetDataTableRowFromName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UDataTable* Table (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName RowName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTableRowBase OutRow (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UDataTableFunctionLibrary::GetDataTableRowFromName(class UDataTable* Table, const struct FName& RowName, struct FTableRowBase* OutRow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DataTableFunctionLibrary.GetDataTableRowFromName");
|
|
|
|
UDataTableFunctionLibrary_GetDataTableRowFromName_Params params;
|
|
params.Table = Table;
|
|
params.RowName = RowName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRow != nullptr)
|
|
*OutRow = params.OutRow;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DataTableFunctionLibrary.EvaluateCurveTableRow
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCurveTable* CurveTable (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName RowName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InXY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EEvaluateCurveTableResult> OutResult (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutXY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ContextString (Parm, ZeroConstructor)
|
|
|
|
void UDataTableFunctionLibrary::EvaluateCurveTableRow(class UCurveTable* CurveTable, const struct FName& RowName, float InXY, const struct FString& ContextString, TEnumAsByte<EEvaluateCurveTableResult>* OutResult, float* OutXY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DataTableFunctionLibrary.EvaluateCurveTableRow");
|
|
|
|
UDataTableFunctionLibrary_EvaluateCurveTableRow_Params params;
|
|
params.CurveTable = CurveTable;
|
|
params.RowName = RowName;
|
|
params.InXY = InXY;
|
|
params.ContextString = ContextString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutResult != nullptr)
|
|
*OutResult = params.OutResult;
|
|
if (OutXY != nullptr)
|
|
*OutXY = params.OutXY;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.ToggleDisplay
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void ADebugCameraController::ToggleDisplay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.ToggleDisplay");
|
|
|
|
ADebugCameraController_ToggleDisplay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.ShowDebugSelectedInfo
|
|
// (Exec, Native, Public)
|
|
|
|
void ADebugCameraController::ShowDebugSelectedInfo()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.ShowDebugSelectedInfo");
|
|
|
|
ADebugCameraController_ShowDebugSelectedInfo_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.SetPawnMovementSpeedScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewSpeedScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADebugCameraController::SetPawnMovementSpeedScale(float NewSpeedScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.SetPawnMovementSpeedScale");
|
|
|
|
ADebugCameraController_SetPawnMovementSpeedScale_Params params;
|
|
params.NewSpeedScale = NewSpeedScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.ReceiveOnDeactivate
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* RestoredPC (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADebugCameraController::ReceiveOnDeactivate(class APlayerController* RestoredPC)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.ReceiveOnDeactivate");
|
|
|
|
ADebugCameraController_ReceiveOnDeactivate_Params params;
|
|
params.RestoredPC = RestoredPC;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.ReceiveOnActorSelected
|
|
// (Event, Protected, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* NewSelectedActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector SelectHitLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector SelectHitNormal (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FHitResult Hit (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void ADebugCameraController::ReceiveOnActorSelected(class AActor* NewSelectedActor, const struct FVector& SelectHitLocation, const struct FVector& SelectHitNormal, const struct FHitResult& Hit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.ReceiveOnActorSelected");
|
|
|
|
ADebugCameraController_ReceiveOnActorSelected_Params params;
|
|
params.NewSelectedActor = NewSelectedActor;
|
|
params.SelectHitLocation = SelectHitLocation;
|
|
params.SelectHitNormal = SelectHitNormal;
|
|
params.Hit = Hit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.ReceiveOnActivate
|
|
// (Event, Public, BlueprintEvent)
|
|
// Parameters:
|
|
// class APlayerController* OriginalPC (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADebugCameraController::ReceiveOnActivate(class APlayerController* OriginalPC)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.ReceiveOnActivate");
|
|
|
|
ADebugCameraController_ReceiveOnActivate_Params params;
|
|
params.OriginalPC = OriginalPC;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DebugCameraController.GetSelectedActor
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class AActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class AActor* ADebugCameraController::GetSelectedActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DebugCameraController.GetSelectedActor");
|
|
|
|
ADebugCameraController_GetSelectedActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalActor.SetDecalMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* NewDecalMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ADecalActor::SetDecalMaterial(class UMaterialInterface* NewDecalMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalActor.SetDecalMaterial");
|
|
|
|
ADecalActor_SetDecalMaterial_Params params;
|
|
params.NewDecalMaterial = NewDecalMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalActor.GetDecalMaterial
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* ADecalActor::GetDecalMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalActor.GetDecalMaterial");
|
|
|
|
ADecalActor_GetDecalMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalActor.CreateDynamicMaterialInstance
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* ADecalActor::CreateDynamicMaterialInstance()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalActor.CreateDynamicMaterialInstance");
|
|
|
|
ADecalActor_CreateDynamicMaterialInstance_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.SetSortOrder
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDecalComponent::SetSortOrder(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.SetSortOrder");
|
|
|
|
UDecalComponent_SetSortOrder_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.SetFadeScreenSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewFadeScreenSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDecalComponent::SetFadeScreenSize(float NewFadeScreenSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.SetFadeScreenSize");
|
|
|
|
UDecalComponent_SetFadeScreenSize_Params params;
|
|
params.NewFadeScreenSize = NewFadeScreenSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.SetFadeOut
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float StartDelay (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool DestroyOwnerAfterFade (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDecalComponent::SetFadeOut(float StartDelay, float Duration, bool DestroyOwnerAfterFade)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.SetFadeOut");
|
|
|
|
UDecalComponent_SetFadeOut_Params params;
|
|
params.StartDelay = StartDelay;
|
|
params.Duration = Duration;
|
|
params.DestroyOwnerAfterFade = DestroyOwnerAfterFade;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.SetDecalMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* NewDecalMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDecalComponent::SetDecalMaterial(class UMaterialInterface* NewDecalMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.SetDecalMaterial");
|
|
|
|
UDecalComponent_SetDecalMaterial_Params params;
|
|
params.NewDecalMaterial = NewDecalMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.GetFadeStartDelay
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UDecalComponent::GetFadeStartDelay()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.GetFadeStartDelay");
|
|
|
|
UDecalComponent_GetFadeStartDelay_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.GetFadeDuration
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UDecalComponent::GetFadeDuration()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.GetFadeDuration");
|
|
|
|
UDecalComponent_GetFadeDuration_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.GetDecalMaterial
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* UDecalComponent::GetDecalMaterial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.GetDecalMaterial");
|
|
|
|
UDecalComponent_GetDecalMaterial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.DecalComponent.CreateDynamicMaterialInstance
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UDecalComponent::CreateDynamicMaterialInstance()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DecalComponent.CreateDynamicMaterialInstance");
|
|
|
|
UDecalComponent_CreateDynamicMaterialInstance_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.ToggleEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void ALight::ToggleEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.ToggleEnabled");
|
|
|
|
ALight_ToggleEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetLightFunctionScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLightFunctionScale (Parm, IsPlainOldData)
|
|
|
|
void ALight::SetLightFunctionScale(const struct FVector& NewLightFunctionScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetLightFunctionScale");
|
|
|
|
ALight_SetLightFunctionScale_Params params;
|
|
params.NewLightFunctionScale = NewLightFunctionScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetLightFunctionMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* NewLightFunctionMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALight::SetLightFunctionMaterial(class UMaterialInterface* NewLightFunctionMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetLightFunctionMaterial");
|
|
|
|
ALight_SetLightFunctionMaterial_Params params;
|
|
params.NewLightFunctionMaterial = NewLightFunctionMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetLightFunctionFadeDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLightFunctionFadeDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALight::SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetLightFunctionFadeDistance");
|
|
|
|
ALight_SetLightFunctionFadeDistance_Params params;
|
|
params.NewLightFunctionFadeDistance = NewLightFunctionFadeDistance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetLightColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewLightColor (Parm, IsPlainOldData)
|
|
|
|
void ALight::SetLightColor(const struct FLinearColor& NewLightColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetLightColor");
|
|
|
|
ALight_SetLightColor_Params params;
|
|
params.NewLightColor = NewLightColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bSetEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALight::SetEnabled(bool bSetEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetEnabled");
|
|
|
|
ALight_SetEnabled_Params params;
|
|
params.bSetEnabled = bSetEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetCastShadows
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALight::SetCastShadows(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetCastShadows");
|
|
|
|
ALight_SetCastShadows_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetBrightness
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewBrightness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALight::SetBrightness(float NewBrightness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetBrightness");
|
|
|
|
ALight_SetBrightness_Params params;
|
|
params.NewBrightness = NewBrightness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.SetAffectTranslucentLighting
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALight::SetAffectTranslucentLighting(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.SetAffectTranslucentLighting");
|
|
|
|
ALight_SetAffectTranslucentLighting_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.OnRep_bEnabled
|
|
// (Native, Public)
|
|
|
|
void ALight::OnRep_bEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.OnRep_bEnabled");
|
|
|
|
ALight_OnRep_bEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.IsEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ALight::IsEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.IsEnabled");
|
|
|
|
ALight_IsEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.GetLightColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor ALight::GetLightColor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.GetLightColor");
|
|
|
|
ALight_GetLightColor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Light.GetBrightness
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float ALight::GetBrightness()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Light.GetBrightness");
|
|
|
|
ALight_GetBrightness_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponentBase.SetCastVolumetricShadow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponentBase::SetCastVolumetricShadow(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponentBase.SetCastVolumetricShadow");
|
|
|
|
ULightComponentBase_SetCastVolumetricShadow_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponentBase.SetCastShadows
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponentBase::SetCastShadows(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponentBase.SetCastShadows");
|
|
|
|
ULightComponentBase_SetCastShadows_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponentBase.GetLightColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor ULightComponentBase::GetLightColor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponentBase.GetLightColor");
|
|
|
|
ULightComponentBase_GetLightColor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetVolumetricScatteringIntensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetVolumetricScatteringIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetVolumetricScatteringIntensity");
|
|
|
|
ULightComponent_SetVolumetricScatteringIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetTemperature
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewTemperature (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetTemperature(float NewTemperature)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetTemperature");
|
|
|
|
ULightComponent_SetTemperature_Params params;
|
|
params.NewTemperature = NewTemperature;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetShadowBias
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetShadowBias(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetShadowBias");
|
|
|
|
ULightComponent_SetShadowBias_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetLightFunctionScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLightFunctionScale (Parm, IsPlainOldData)
|
|
|
|
void ULightComponent::SetLightFunctionScale(const struct FVector& NewLightFunctionScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetLightFunctionScale");
|
|
|
|
ULightComponent_SetLightFunctionScale_Params params;
|
|
params.NewLightFunctionScale = NewLightFunctionScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetLightFunctionMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* NewLightFunctionMaterial (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetLightFunctionMaterial(class UMaterialInterface* NewLightFunctionMaterial)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetLightFunctionMaterial");
|
|
|
|
ULightComponent_SetLightFunctionMaterial_Params params;
|
|
params.NewLightFunctionMaterial = NewLightFunctionMaterial;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetLightFunctionFadeDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLightFunctionFadeDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetLightFunctionFadeDistance(float NewLightFunctionFadeDistance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetLightFunctionFadeDistance");
|
|
|
|
ULightComponent_SetLightFunctionFadeDistance_Params params;
|
|
params.NewLightFunctionFadeDistance = NewLightFunctionFadeDistance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetLightFunctionDisabledBrightness
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetLightFunctionDisabledBrightness(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetLightFunctionDisabledBrightness");
|
|
|
|
ULightComponent_SetLightFunctionDisabledBrightness_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetLightColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewLightColor (Parm, IsPlainOldData)
|
|
// bool bSRGB (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetLightColor(const struct FLinearColor& NewLightColor, bool bSRGB)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetLightColor");
|
|
|
|
ULightComponent_SetLightColor_Params params;
|
|
params.NewLightColor = NewLightColor;
|
|
params.bSRGB = bSRGB;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetIntensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetIntensity");
|
|
|
|
ULightComponent_SetIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetIndirectLightingIntensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetIndirectLightingIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetIndirectLightingIntensity");
|
|
|
|
ULightComponent_SetIndirectLightingIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetIESTexture
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTextureLightProfile* NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetIESTexture(class UTextureLightProfile* NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetIESTexture");
|
|
|
|
ULightComponent_SetIESTexture_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetEnableLightShaftBloom
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetEnableLightShaftBloom(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetEnableLightShaftBloom");
|
|
|
|
ULightComponent_SetEnableLightShaftBloom_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetBloomTint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FColor NewValue (Parm, IsPlainOldData)
|
|
|
|
void ULightComponent::SetBloomTint(const struct FColor& NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetBloomTint");
|
|
|
|
ULightComponent_SetBloomTint_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetBloomThreshold
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetBloomThreshold(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetBloomThreshold");
|
|
|
|
ULightComponent_SetBloomThreshold_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetBloomScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetBloomScale(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetBloomScale");
|
|
|
|
ULightComponent_SetBloomScale_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetAffectTranslucentLighting
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetAffectTranslucentLighting(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetAffectTranslucentLighting");
|
|
|
|
ULightComponent_SetAffectTranslucentLighting_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LightComponent.SetAffectDynamicIndirectLighting
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ULightComponent::SetAffectDynamicIndirectLighting(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LightComponent.SetAffectDynamicIndirectLighting");
|
|
|
|
ULightComponent_SetAffectDynamicIndirectLighting_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetShadowDistanceFadeoutFraction
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetShadowDistanceFadeoutFraction(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetShadowDistanceFadeoutFraction");
|
|
|
|
UDirectionalLightComponent_SetShadowDistanceFadeoutFraction_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetOcclusionMaskDarkness
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetOcclusionMaskDarkness(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetOcclusionMaskDarkness");
|
|
|
|
UDirectionalLightComponent_SetOcclusionMaskDarkness_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetLightShaftOverrideDirection
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewValue (Parm, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetLightShaftOverrideDirection(const struct FVector& NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetLightShaftOverrideDirection");
|
|
|
|
UDirectionalLightComponent_SetLightShaftOverrideDirection_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetEnableLightShaftOcclusion
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetEnableLightShaftOcclusion(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetEnableLightShaftOcclusion");
|
|
|
|
UDirectionalLightComponent_SetEnableLightShaftOcclusion_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetDynamicShadowDistanceStationaryLight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetDynamicShadowDistanceStationaryLight(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetDynamicShadowDistanceStationaryLight");
|
|
|
|
UDirectionalLightComponent_SetDynamicShadowDistanceStationaryLight_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetDynamicShadowDistanceMovableLight
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetDynamicShadowDistanceMovableLight(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetDynamicShadowDistanceMovableLight");
|
|
|
|
UDirectionalLightComponent_SetDynamicShadowDistanceMovableLight_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetDynamicShadowCascades
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetDynamicShadowCascades(int NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetDynamicShadowCascades");
|
|
|
|
UDirectionalLightComponent_SetDynamicShadowCascades_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetCascadeTransitionFraction
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetCascadeTransitionFraction(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetCascadeTransitionFraction");
|
|
|
|
UDirectionalLightComponent_SetCascadeTransitionFraction_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.DirectionalLightComponent.SetCascadeDistributionExponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UDirectionalLightComponent::SetCascadeDistributionExponent(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.DirectionalLightComponent.SetCascadeDistributionExponent");
|
|
|
|
UDirectionalLightComponent_SetCascadeDistributionExponent_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.ToggleActive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void AEmitter::ToggleActive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.ToggleActive");
|
|
|
|
AEmitter_ToggleActive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.SetVectorParameter
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Param (Parm, IsPlainOldData)
|
|
|
|
void AEmitter::SetVectorParameter(const struct FName& ParameterName, const struct FVector& Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.SetVectorParameter");
|
|
|
|
AEmitter_SetVectorParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.SetTemplate
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UParticleSystem* NewTemplate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AEmitter::SetTemplate(class UParticleSystem* NewTemplate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.SetTemplate");
|
|
|
|
AEmitter_SetTemplate_Params params;
|
|
params.NewTemplate = NewTemplate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.SetMaterialParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Param (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AEmitter::SetMaterialParameter(const struct FName& ParameterName, class UMaterialInterface* Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.SetMaterialParameter");
|
|
|
|
AEmitter_SetMaterialParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.SetFloatParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Param (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AEmitter::SetFloatParameter(const struct FName& ParameterName, float Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.SetFloatParameter");
|
|
|
|
AEmitter_SetFloatParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.SetColorParameter
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Param (Parm, IsPlainOldData)
|
|
|
|
void AEmitter::SetColorParameter(const struct FName& ParameterName, const struct FLinearColor& Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.SetColorParameter");
|
|
|
|
AEmitter_SetColorParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.SetActorParameter
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Param (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AEmitter::SetActorParameter(const struct FName& ParameterName, class AActor* Param)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.SetActorParameter");
|
|
|
|
AEmitter_SetActorParameter_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Param = Param;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.OnRep_bCurrentlyActive
|
|
// (Native, Public)
|
|
|
|
void AEmitter::OnRep_bCurrentlyActive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.OnRep_bCurrentlyActive");
|
|
|
|
AEmitter_OnRep_bCurrentlyActive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.OnParticleSystemFinished
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// class UParticleSystemComponent* FinishedComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void AEmitter::OnParticleSystemFinished(class UParticleSystemComponent* FinishedComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.OnParticleSystemFinished");
|
|
|
|
AEmitter_OnParticleSystemFinished_Params params;
|
|
params.FinishedComponent = FinishedComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.IsActive
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool AEmitter::IsActive()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.IsActive");
|
|
|
|
AEmitter_IsActive_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.Deactivate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void AEmitter::Deactivate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.Deactivate");
|
|
|
|
AEmitter_Deactivate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.Emitter.Activate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void AEmitter::Activate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Emitter.Activate");
|
|
|
|
AEmitter_Activate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFog.OnRep_bEnabled
|
|
// (Native, Public)
|
|
|
|
void AExponentialHeightFog::OnRep_bEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFog.OnRep_bEnabled");
|
|
|
|
AExponentialHeightFog_OnRep_bEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetVolumetricFogScatteringDistribution
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetVolumetricFogScatteringDistribution(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetVolumetricFogScatteringDistribution");
|
|
|
|
UExponentialHeightFogComponent_SetVolumetricFogScatteringDistribution_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetVolumetricFogExtinctionScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetVolumetricFogExtinctionScale(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetVolumetricFogExtinctionScale");
|
|
|
|
UExponentialHeightFogComponent_SetVolumetricFogExtinctionScale_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetVolumetricFogEmissive
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewValue (Parm, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetVolumetricFogEmissive(const struct FLinearColor& NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetVolumetricFogEmissive");
|
|
|
|
UExponentialHeightFogComponent_SetVolumetricFogEmissive_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetVolumetricFogDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetVolumetricFogDistance(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetVolumetricFogDistance");
|
|
|
|
UExponentialHeightFogComponent_SetVolumetricFogDistance_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetVolumetricFogAlbedo
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FColor NewValue (Parm, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetVolumetricFogAlbedo(const struct FColor& NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetVolumetricFogAlbedo");
|
|
|
|
UExponentialHeightFogComponent_SetVolumetricFogAlbedo_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetVolumetricFog
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetVolumetricFog(bool bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetVolumetricFog");
|
|
|
|
UExponentialHeightFogComponent_SetVolumetricFog_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetStartDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetStartDistance(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetStartDistance");
|
|
|
|
UExponentialHeightFogComponent_SetStartDistance_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetNonDirectionalInscatteringColorDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetNonDirectionalInscatteringColorDistance(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetNonDirectionalInscatteringColorDistance");
|
|
|
|
UExponentialHeightFogComponent_SetNonDirectionalInscatteringColorDistance_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetInscatteringTextureTint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor Value (Parm, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetInscatteringTextureTint(const struct FLinearColor& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetInscatteringTextureTint");
|
|
|
|
UExponentialHeightFogComponent_SetInscatteringTextureTint_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetInscatteringColorCubemapAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetInscatteringColorCubemapAngle(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetInscatteringColorCubemapAngle");
|
|
|
|
UExponentialHeightFogComponent_SetInscatteringColorCubemapAngle_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetInscatteringColorCubemap
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTextureCube* Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetInscatteringColorCubemap(class UTextureCube* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetInscatteringColorCubemap");
|
|
|
|
UExponentialHeightFogComponent_SetInscatteringColorCubemap_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetFullyDirectionalInscatteringColorDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetFullyDirectionalInscatteringColorDistance(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetFullyDirectionalInscatteringColorDistance");
|
|
|
|
UExponentialHeightFogComponent_SetFullyDirectionalInscatteringColorDistance_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetFogMaxOpacity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetFogMaxOpacity(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetFogMaxOpacity");
|
|
|
|
UExponentialHeightFogComponent_SetFogMaxOpacity_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetFogInscatteringColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor Value (Parm, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetFogInscatteringColor(const struct FLinearColor& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetFogInscatteringColor");
|
|
|
|
UExponentialHeightFogComponent_SetFogInscatteringColor_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetFogHeightFalloff
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetFogHeightFalloff(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetFogHeightFalloff");
|
|
|
|
UExponentialHeightFogComponent_SetFogHeightFalloff_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetFogDensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetFogDensity(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetFogDensity");
|
|
|
|
UExponentialHeightFogComponent_SetFogDensity_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetFogCutoffDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetFogCutoffDistance(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetFogCutoffDistance");
|
|
|
|
UExponentialHeightFogComponent_SetFogCutoffDistance_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetDirectionalInscatteringStartDistance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetDirectionalInscatteringStartDistance(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetDirectionalInscatteringStartDistance");
|
|
|
|
UExponentialHeightFogComponent_SetDirectionalInscatteringStartDistance_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetDirectionalInscatteringExponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetDirectionalInscatteringExponent(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetDirectionalInscatteringExponent");
|
|
|
|
UExponentialHeightFogComponent_SetDirectionalInscatteringExponent_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetDirectionalInscatteringColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor Value (Parm, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetDirectionalInscatteringColor(const struct FLinearColor& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetDirectionalInscatteringColor");
|
|
|
|
UExponentialHeightFogComponent_SetDirectionalInscatteringColor_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetCustomFogInscatteringColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor Value (Parm, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetCustomFogInscatteringColor(const struct FLinearColor& Value, int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetCustomFogInscatteringColor");
|
|
|
|
UExponentialHeightFogComponent_SetCustomFogInscatteringColor_Params params;
|
|
params.Value = Value;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ExponentialHeightFogComponent.SetCustomFogDensityCoefficient
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UExponentialHeightFogComponent::SetCustomFogDensityCoefficient(float Value, int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ExponentialHeightFogComponent.SetCustomFogDensityCoefficient");
|
|
|
|
UExponentialHeightFogComponent_SetCustomFogDensityCoefficient_Params params;
|
|
params.Value = Value;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ForceFeedbackComponent.Stop
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UForceFeedbackComponent::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ForceFeedbackComponent.Stop");
|
|
|
|
UForceFeedbackComponent_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ForceFeedbackComponent.SetIntensityMultiplier
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensityMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UForceFeedbackComponent::SetIntensityMultiplier(float NewIntensityMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ForceFeedbackComponent.SetIntensityMultiplier");
|
|
|
|
UForceFeedbackComponent_SetIntensityMultiplier_Params params;
|
|
params.NewIntensityMultiplier = NewIntensityMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ForceFeedbackComponent.SetForceFeedbackEffect
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UForceFeedbackEffect* NewForceFeedbackEffect (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UForceFeedbackComponent::SetForceFeedbackEffect(class UForceFeedbackEffect* NewForceFeedbackEffect)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ForceFeedbackComponent.SetForceFeedbackEffect");
|
|
|
|
UForceFeedbackComponent_SetForceFeedbackEffect_Params params;
|
|
params.NewForceFeedbackEffect = NewForceFeedbackEffect;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ForceFeedbackComponent.Play
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float StartTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UForceFeedbackComponent::Play(float StartTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ForceFeedbackComponent.Play");
|
|
|
|
UForceFeedbackComponent_Play_Params params;
|
|
params.StartTime = StartTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ForceFeedbackComponent.BP_GetAttenuationSettingsToApply
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FForceFeedbackAttenuationSettings OutAttenuationSettings (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UForceFeedbackComponent::BP_GetAttenuationSettingsToApply(struct FForceFeedbackAttenuationSettings* OutAttenuationSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ForceFeedbackComponent.BP_GetAttenuationSettingsToApply");
|
|
|
|
UForceFeedbackComponent_BP_GetAttenuationSettingsToApply_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutAttenuationSettings != nullptr)
|
|
*OutAttenuationSettings = params.OutAttenuationSettings;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ForceFeedbackComponent.AdjustAttenuation
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FForceFeedbackAttenuationSettings InAttenuationSettings (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UForceFeedbackComponent::AdjustAttenuation(const struct FForceFeedbackAttenuationSettings& InAttenuationSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ForceFeedbackComponent.AdjustAttenuation");
|
|
|
|
UForceFeedbackComponent_AdjustAttenuation_Params params;
|
|
params.InAttenuationSettings = InAttenuationSettings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ValidateSettings
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::ValidateSettings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ValidateSettings");
|
|
|
|
UGameUserSettings_ValidateSettings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SupportsHDRDisplayOutput
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::SupportsHDRDisplayOutput()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SupportsHDRDisplayOutput");
|
|
|
|
UGameUserSettings_SupportsHDRDisplayOutput_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetVSyncEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetVSyncEnabled(bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetVSyncEnabled");
|
|
|
|
UGameUserSettings_SetVSyncEnabled_Params params;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetVisualEffectQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetVisualEffectQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetVisualEffectQuality");
|
|
|
|
UGameUserSettings_SetVisualEffectQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetViewDistanceQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetViewDistanceQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetViewDistanceQuality");
|
|
|
|
UGameUserSettings_SetViewDistanceQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetToDefaults
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::SetToDefaults()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetToDefaults");
|
|
|
|
UGameUserSettings_SetToDefaults_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetTextureQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetTextureQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetTextureQuality");
|
|
|
|
UGameUserSettings_SetTextureQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetShadowQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetShadowQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetShadowQuality");
|
|
|
|
UGameUserSettings_SetShadowQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetScreenResolution
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FIntPoint Resolution (Parm, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetScreenResolution(const struct FIntPoint& Resolution)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetScreenResolution");
|
|
|
|
UGameUserSettings_SetScreenResolution_Params params;
|
|
params.Resolution = Resolution;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetResolutionScaleValueEx
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewScaleValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetResolutionScaleValueEx(float NewScaleValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetResolutionScaleValueEx");
|
|
|
|
UGameUserSettings_SetResolutionScaleValueEx_Params params;
|
|
params.NewScaleValue = NewScaleValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetResolutionScaleValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewScaleValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetResolutionScaleValue(int NewScaleValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetResolutionScaleValue");
|
|
|
|
UGameUserSettings_SetResolutionScaleValue_Params params;
|
|
params.NewScaleValue = NewScaleValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetResolutionScaleNormalized
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewScaleNormalized (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetResolutionScaleNormalized(float NewScaleNormalized)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetResolutionScaleNormalized");
|
|
|
|
UGameUserSettings_SetResolutionScaleNormalized_Params params;
|
|
params.NewScaleNormalized = NewScaleNormalized;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetPostProcessingQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetPostProcessingQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetPostProcessingQuality");
|
|
|
|
UGameUserSettings_SetPostProcessingQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetOverallScalabilityLevel
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetOverallScalabilityLevel(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetOverallScalabilityLevel");
|
|
|
|
UGameUserSettings_SetOverallScalabilityLevel_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetFullscreenMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EWindowMode> InFullscreenMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetFullscreenMode(TEnumAsByte<EWindowMode> InFullscreenMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetFullscreenMode");
|
|
|
|
UGameUserSettings_SetFullscreenMode_Params params;
|
|
params.InFullscreenMode = InFullscreenMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetFrameRateLimit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLimit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetFrameRateLimit(float NewLimit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetFrameRateLimit");
|
|
|
|
UGameUserSettings_SetFrameRateLimit_Params params;
|
|
params.NewLimit = NewLimit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetFoliageQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetFoliageQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetFoliageQuality");
|
|
|
|
UGameUserSettings_SetFoliageQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetBenchmarkFallbackValues
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::SetBenchmarkFallbackValues()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetBenchmarkFallbackValues");
|
|
|
|
UGameUserSettings_SetBenchmarkFallbackValues_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetAudioQualityLevel
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int QualityLevel (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetAudioQualityLevel(int QualityLevel)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetAudioQualityLevel");
|
|
|
|
UGameUserSettings_SetAudioQualityLevel_Params params;
|
|
params.QualityLevel = QualityLevel;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SetAntiAliasingQuality
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::SetAntiAliasingQuality(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SetAntiAliasingQuality");
|
|
|
|
UGameUserSettings_SetAntiAliasingQuality_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.SaveSettings
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::SaveSettings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.SaveSettings");
|
|
|
|
UGameUserSettings_SaveSettings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.RunHardwareBenchmark
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int WorkScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float CPUMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float GPUMultiplier (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::RunHardwareBenchmark(int WorkScale, float CPUMultiplier, float GPUMultiplier)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.RunHardwareBenchmark");
|
|
|
|
UGameUserSettings_RunHardwareBenchmark_Params params;
|
|
params.WorkScale = WorkScale;
|
|
params.CPUMultiplier = CPUMultiplier;
|
|
params.GPUMultiplier = GPUMultiplier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.RevertVideoMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::RevertVideoMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.RevertVideoMode");
|
|
|
|
UGameUserSettings_RevertVideoMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ResetToCurrentSettings
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::ResetToCurrentSettings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ResetToCurrentSettings");
|
|
|
|
UGameUserSettings_ResetToCurrentSettings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.LoadSettings
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bForceReload (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::LoadSettings(bool bForceReload)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.LoadSettings");
|
|
|
|
UGameUserSettings_LoadSettings_Params params;
|
|
params.bForceReload = bForceReload;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.IsVSyncEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::IsVSyncEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.IsVSyncEnabled");
|
|
|
|
UGameUserSettings_IsVSyncEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.IsVSyncDirty
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::IsVSyncDirty()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.IsVSyncDirty");
|
|
|
|
UGameUserSettings_IsVSyncDirty_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.IsScreenResolutionDirty
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::IsScreenResolutionDirty()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.IsScreenResolutionDirty");
|
|
|
|
UGameUserSettings_IsScreenResolutionDirty_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.IsHDREnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::IsHDREnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.IsHDREnabled");
|
|
|
|
UGameUserSettings_IsHDREnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.IsFullscreenModeDirty
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::IsFullscreenModeDirty()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.IsFullscreenModeDirty");
|
|
|
|
UGameUserSettings_IsFullscreenModeDirty_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.IsDirty
|
|
// (Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UGameUserSettings::IsDirty()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.IsDirty");
|
|
|
|
UGameUserSettings_IsDirty_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetVisualEffectQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetVisualEffectQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetVisualEffectQuality");
|
|
|
|
UGameUserSettings_GetVisualEffectQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetViewDistanceQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetViewDistanceQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetViewDistanceQuality");
|
|
|
|
UGameUserSettings_GetViewDistanceQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetTextureQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetTextureQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetTextureQuality");
|
|
|
|
UGameUserSettings_GetTextureQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetShadowQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetShadowQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetShadowQuality");
|
|
|
|
UGameUserSettings_GetShadowQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetScreenResolution
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FIntPoint ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntPoint UGameUserSettings::GetScreenResolution()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetScreenResolution");
|
|
|
|
UGameUserSettings_GetScreenResolution_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetResolutionScaleInformationEx
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float CurrentScaleNormalized (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float CurrentScaleValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float MinScaleValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxScaleValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::GetResolutionScaleInformationEx(float* CurrentScaleNormalized, float* CurrentScaleValue, float* MinScaleValue, float* MaxScaleValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetResolutionScaleInformationEx");
|
|
|
|
UGameUserSettings_GetResolutionScaleInformationEx_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (CurrentScaleNormalized != nullptr)
|
|
*CurrentScaleNormalized = params.CurrentScaleNormalized;
|
|
if (CurrentScaleValue != nullptr)
|
|
*CurrentScaleValue = params.CurrentScaleValue;
|
|
if (MinScaleValue != nullptr)
|
|
*MinScaleValue = params.MinScaleValue;
|
|
if (MaxScaleValue != nullptr)
|
|
*MaxScaleValue = params.MaxScaleValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetResolutionScaleInformation
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float CurrentScaleNormalized (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int CurrentScaleValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int MinScaleValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int MaxScaleValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::GetResolutionScaleInformation(float* CurrentScaleNormalized, int* CurrentScaleValue, int* MinScaleValue, int* MaxScaleValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetResolutionScaleInformation");
|
|
|
|
UGameUserSettings_GetResolutionScaleInformation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (CurrentScaleNormalized != nullptr)
|
|
*CurrentScaleNormalized = params.CurrentScaleNormalized;
|
|
if (CurrentScaleValue != nullptr)
|
|
*CurrentScaleValue = params.CurrentScaleValue;
|
|
if (MinScaleValue != nullptr)
|
|
*MinScaleValue = params.MinScaleValue;
|
|
if (MaxScaleValue != nullptr)
|
|
*MaxScaleValue = params.MaxScaleValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetRecommendedResolutionScale
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameUserSettings::GetRecommendedResolutionScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetRecommendedResolutionScale");
|
|
|
|
UGameUserSettings_GetRecommendedResolutionScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetPreferredFullscreenMode
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EWindowMode> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EWindowMode> UGameUserSettings::GetPreferredFullscreenMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetPreferredFullscreenMode");
|
|
|
|
UGameUserSettings_GetPreferredFullscreenMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetPostProcessingQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetPostProcessingQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetPostProcessingQuality");
|
|
|
|
UGameUserSettings_GetPostProcessingQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetOverallScalabilityLevel
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetOverallScalabilityLevel()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetOverallScalabilityLevel");
|
|
|
|
UGameUserSettings_GetOverallScalabilityLevel_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetLastConfirmedScreenResolution
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FIntPoint ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntPoint UGameUserSettings::GetLastConfirmedScreenResolution()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetLastConfirmedScreenResolution");
|
|
|
|
UGameUserSettings_GetLastConfirmedScreenResolution_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetLastConfirmedFullscreenMode
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EWindowMode> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EWindowMode> UGameUserSettings::GetLastConfirmedFullscreenMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetLastConfirmedFullscreenMode");
|
|
|
|
UGameUserSettings_GetLastConfirmedFullscreenMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetGameUserSettings
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UGameUserSettings* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UGameUserSettings* UGameUserSettings::GetGameUserSettings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetGameUserSettings");
|
|
|
|
UGameUserSettings_GetGameUserSettings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetFullscreenMode
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EWindowMode> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EWindowMode> UGameUserSettings::GetFullscreenMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetFullscreenMode");
|
|
|
|
UGameUserSettings_GetFullscreenMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetFrameRateLimit
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameUserSettings::GetFrameRateLimit()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetFrameRateLimit");
|
|
|
|
UGameUserSettings_GetFrameRateLimit_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetFoliageQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetFoliageQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetFoliageQuality");
|
|
|
|
UGameUserSettings_GetFoliageQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetDesktopResolution
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FIntPoint ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntPoint UGameUserSettings::GetDesktopResolution()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetDesktopResolution");
|
|
|
|
UGameUserSettings_GetDesktopResolution_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetDefaultWindowPosition
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FIntPoint ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntPoint UGameUserSettings::GetDefaultWindowPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetDefaultWindowPosition");
|
|
|
|
UGameUserSettings_GetDefaultWindowPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetDefaultWindowMode
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EWindowMode> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<EWindowMode> UGameUserSettings::GetDefaultWindowMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetDefaultWindowMode");
|
|
|
|
UGameUserSettings_GetDefaultWindowMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetDefaultResolutionScale
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UGameUserSettings::GetDefaultResolutionScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetDefaultResolutionScale");
|
|
|
|
UGameUserSettings_GetDefaultResolutionScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetDefaultResolution
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FIntPoint ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntPoint UGameUserSettings::GetDefaultResolution()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetDefaultResolution");
|
|
|
|
UGameUserSettings_GetDefaultResolution_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetCurrentHDRDisplayNits
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetCurrentHDRDisplayNits()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetCurrentHDRDisplayNits");
|
|
|
|
UGameUserSettings_GetCurrentHDRDisplayNits_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetAudioQualityLevel
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetAudioQualityLevel()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetAudioQualityLevel");
|
|
|
|
UGameUserSettings_GetAudioQualityLevel_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.GetAntiAliasingQuality
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UGameUserSettings::GetAntiAliasingQuality()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.GetAntiAliasingQuality");
|
|
|
|
UGameUserSettings_GetAntiAliasingQuality_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.EnableHDRDisplayOutput
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int DisplayNits (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::EnableHDRDisplayOutput(bool bEnable, int DisplayNits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.EnableHDRDisplayOutput");
|
|
|
|
UGameUserSettings_EnableHDRDisplayOutput_Params params;
|
|
params.bEnable = bEnable;
|
|
params.DisplayNits = DisplayNits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ConfirmVideoMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::ConfirmVideoMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ConfirmVideoMode");
|
|
|
|
UGameUserSettings_ConfirmVideoMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ApplySettings
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bCheckForCommandLineOverrides (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::ApplySettings(bool bCheckForCommandLineOverrides)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ApplySettings");
|
|
|
|
UGameUserSettings_ApplySettings_Params params;
|
|
params.bCheckForCommandLineOverrides = bCheckForCommandLineOverrides;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ApplyResolutionSettings
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bCheckForCommandLineOverrides (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UGameUserSettings::ApplyResolutionSettings(bool bCheckForCommandLineOverrides)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ApplyResolutionSettings");
|
|
|
|
UGameUserSettings_ApplyResolutionSettings_Params params;
|
|
params.bCheckForCommandLineOverrides = bCheckForCommandLineOverrides;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ApplyNonResolutionSettings
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::ApplyNonResolutionSettings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ApplyNonResolutionSettings");
|
|
|
|
UGameUserSettings_ApplyNonResolutionSettings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.GameUserSettings.ApplyHardwareBenchmarkResults
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UGameUserSettings::ApplyHardwareBenchmarkResults()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.GameUserSettings.ApplyHardwareBenchmarkResults");
|
|
|
|
UGameUserSettings_ApplyHardwareBenchmarkResults_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SpotLight.SetOuterConeAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewOuterConeAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ASpotLight::SetOuterConeAngle(float NewOuterConeAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SpotLight.SetOuterConeAngle");
|
|
|
|
ASpotLight_SetOuterConeAngle_Params params;
|
|
params.NewOuterConeAngle = NewOuterConeAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SpotLight.SetInnerConeAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewInnerConeAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ASpotLight::SetInnerConeAngle(float NewInnerConeAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SpotLight.SetInnerConeAngle");
|
|
|
|
ASpotLight_SetInnerConeAngle_Params params;
|
|
params.NewInnerConeAngle = NewInnerConeAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.RandomSobolFloat
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Dimension (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Seed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UImportanceSamplingLibrary::RandomSobolFloat(int Index, int Dimension, float Seed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.RandomSobolFloat");
|
|
|
|
UImportanceSamplingLibrary_RandomSobolFloat_Params params;
|
|
params.Index = Index;
|
|
params.Dimension = Dimension;
|
|
params.Seed = Seed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.RandomSobolCell3D
|
|
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumCells (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Cell (Parm, IsPlainOldData)
|
|
// struct FVector Seed (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UImportanceSamplingLibrary::RandomSobolCell3D(int Index, int NumCells, const struct FVector& Cell, const struct FVector& Seed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.RandomSobolCell3D");
|
|
|
|
UImportanceSamplingLibrary_RandomSobolCell3D_Params params;
|
|
params.Index = Index;
|
|
params.NumCells = NumCells;
|
|
params.Cell = Cell;
|
|
params.Seed = Seed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.RandomSobolCell2D
|
|
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumCells (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D Cell (Parm, IsPlainOldData)
|
|
// struct FVector2D Seed (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UImportanceSamplingLibrary::RandomSobolCell2D(int Index, int NumCells, const struct FVector2D& Cell, const struct FVector2D& Seed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.RandomSobolCell2D");
|
|
|
|
UImportanceSamplingLibrary_RandomSobolCell2D_Params params;
|
|
params.Index = Index;
|
|
params.NumCells = NumCells;
|
|
params.Cell = Cell;
|
|
params.Seed = Seed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.NextSobolFloat
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Dimension (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float PreviousValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UImportanceSamplingLibrary::NextSobolFloat(int Index, int Dimension, float PreviousValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.NextSobolFloat");
|
|
|
|
UImportanceSamplingLibrary_NextSobolFloat_Params params;
|
|
params.Index = Index;
|
|
params.Dimension = Dimension;
|
|
params.PreviousValue = PreviousValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.NextSobolCell3D
|
|
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumCells (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector PreviousValue (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UImportanceSamplingLibrary::NextSobolCell3D(int Index, int NumCells, const struct FVector& PreviousValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.NextSobolCell3D");
|
|
|
|
UImportanceSamplingLibrary_NextSobolCell3D_Params params;
|
|
params.Index = Index;
|
|
params.NumCells = NumCells;
|
|
params.PreviousValue = PreviousValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.NextSobolCell2D
|
|
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumCells (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D PreviousValue (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UImportanceSamplingLibrary::NextSobolCell2D(int Index, int NumCells, const struct FVector2D& PreviousValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.NextSobolCell2D");
|
|
|
|
UImportanceSamplingLibrary_NextSobolCell2D_Params params;
|
|
params.Index = Index;
|
|
params.NumCells = NumCells;
|
|
params.PreviousValue = PreviousValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.MakeImportanceTexture
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EImportanceWeight> WeightingFunc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FImportanceTexture ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FImportanceTexture UImportanceSamplingLibrary::MakeImportanceTexture(class UTexture2D* Texture, TEnumAsByte<EImportanceWeight> WeightingFunc)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.MakeImportanceTexture");
|
|
|
|
UImportanceSamplingLibrary_MakeImportanceTexture_Params params;
|
|
params.Texture = Texture;
|
|
params.WeightingFunc = WeightingFunc;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.ImportanceSample
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FImportanceTexture Texture (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D Rand (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// int Samples (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Intensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D SamplePosition (Parm, OutParm, IsPlainOldData)
|
|
// struct FLinearColor SampleColor (Parm, OutParm, IsPlainOldData)
|
|
// float SampleIntensity (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float SampleSize (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImportanceSamplingLibrary::ImportanceSample(const struct FImportanceTexture& Texture, const struct FVector2D& Rand, int Samples, float Intensity, struct FVector2D* SamplePosition, struct FLinearColor* SampleColor, float* SampleIntensity, float* SampleSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.ImportanceSample");
|
|
|
|
UImportanceSamplingLibrary_ImportanceSample_Params params;
|
|
params.Texture = Texture;
|
|
params.Rand = Rand;
|
|
params.Samples = Samples;
|
|
params.Intensity = Intensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SamplePosition != nullptr)
|
|
*SamplePosition = params.SamplePosition;
|
|
if (SampleColor != nullptr)
|
|
*SampleColor = params.SampleColor;
|
|
if (SampleIntensity != nullptr)
|
|
*SampleIntensity = params.SampleIntensity;
|
|
if (SampleSize != nullptr)
|
|
*SampleSize = params.SampleSize;
|
|
}
|
|
|
|
|
|
// Function Engine.ImportanceSamplingLibrary.BreakImportanceTexture
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FImportanceTexture ImportanceTexture (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// class UTexture2D* Texture (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EImportanceWeight> WeightingFunc (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UImportanceSamplingLibrary::BreakImportanceTexture(const struct FImportanceTexture& ImportanceTexture, class UTexture2D** Texture, TEnumAsByte<EImportanceWeight>* WeightingFunc)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ImportanceSamplingLibrary.BreakImportanceTexture");
|
|
|
|
UImportanceSamplingLibrary_BreakImportanceTexture_Params params;
|
|
params.ImportanceTexture = ImportanceTexture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Texture != nullptr)
|
|
*Texture = params.Texture;
|
|
if (WeightingFunc != nullptr)
|
|
*WeightingFunc = params.WeightingFunc;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.WasControllerKeyJustReleased
|
|
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInputComponent::WasControllerKeyJustReleased(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.WasControllerKeyJustReleased");
|
|
|
|
UInputComponent_WasControllerKeyJustReleased_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.WasControllerKeyJustPressed
|
|
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInputComponent::WasControllerKeyJustPressed(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.WasControllerKeyJustPressed");
|
|
|
|
UInputComponent_WasControllerKeyJustPressed_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.IsControllerKeyDown
|
|
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UInputComponent::IsControllerKeyDown(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.IsControllerKeyDown");
|
|
|
|
UInputComponent_IsControllerKeyDown_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.GetTouchState
|
|
// (Final, Native, Private, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int FingerIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float LocationY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIsCurrentlyPressed (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputComponent::GetTouchState(int FingerIndex, float* LocationX, float* LocationY, bool* bIsCurrentlyPressed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.GetTouchState");
|
|
|
|
UInputComponent_GetTouchState_Params params;
|
|
params.FingerIndex = FingerIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LocationX != nullptr)
|
|
*LocationX = params.LocationX;
|
|
if (LocationY != nullptr)
|
|
*LocationY = params.LocationY;
|
|
if (bIsCurrentlyPressed != nullptr)
|
|
*bIsCurrentlyPressed = params.bIsCurrentlyPressed;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.GetControllerVectorKeyState
|
|
// (Final, Native, Private, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UInputComponent::GetControllerVectorKeyState(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.GetControllerVectorKeyState");
|
|
|
|
UInputComponent_GetControllerVectorKeyState_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.GetControllerMouseDelta
|
|
// (Final, Native, Private, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float DeltaX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float DeltaY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputComponent::GetControllerMouseDelta(float* DeltaX, float* DeltaY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.GetControllerMouseDelta");
|
|
|
|
UInputComponent_GetControllerMouseDelta_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (DeltaX != nullptr)
|
|
*DeltaX = params.DeltaX;
|
|
if (DeltaY != nullptr)
|
|
*DeltaY = params.DeltaY;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.GetControllerKeyTimeDown
|
|
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UInputComponent::GetControllerKeyTimeDown(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.GetControllerKeyTimeDown");
|
|
|
|
UInputComponent_GetControllerKeyTimeDown_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.GetControllerAnalogStickState
|
|
// (Final, Native, Private, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<EControllerAnalogStick> WhichStick (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float StickX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float StickY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputComponent::GetControllerAnalogStickState(TEnumAsByte<EControllerAnalogStick> WhichStick, float* StickX, float* StickY)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.GetControllerAnalogStickState");
|
|
|
|
UInputComponent_GetControllerAnalogStickState_Params params;
|
|
params.WhichStick = WhichStick;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (StickX != nullptr)
|
|
*StickX = params.StickX;
|
|
if (StickY != nullptr)
|
|
*StickY = params.StickY;
|
|
}
|
|
|
|
|
|
// Function Engine.InputComponent.GetControllerAnalogKeyState
|
|
// (Final, Native, Private, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FKey Key (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UInputComponent::GetControllerAnalogKeyState(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputComponent.GetControllerAnalogKeyState");
|
|
|
|
UInputComponent_GetControllerAnalogKeyState_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.SaveKeyMappings
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UInputSettings::SaveKeyMappings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.SaveKeyMappings");
|
|
|
|
UInputSettings_SaveKeyMappings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.RemoveAxisMapping
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FInputAxisKeyMapping KeyMapping (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool bForceRebuildKeymaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputSettings::RemoveAxisMapping(const struct FInputAxisKeyMapping& KeyMapping, bool bForceRebuildKeymaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.RemoveAxisMapping");
|
|
|
|
UInputSettings_RemoveAxisMapping_Params params;
|
|
params.KeyMapping = KeyMapping;
|
|
params.bForceRebuildKeymaps = bForceRebuildKeymaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.RemoveActionMapping
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FInputActionKeyMapping KeyMapping (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool bForceRebuildKeymaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputSettings::RemoveActionMapping(const struct FInputActionKeyMapping& KeyMapping, bool bForceRebuildKeymaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.RemoveActionMapping");
|
|
|
|
UInputSettings_RemoveActionMapping_Params params;
|
|
params.KeyMapping = KeyMapping;
|
|
params.bForceRebuildKeymaps = bForceRebuildKeymaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.GetInputSettings
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UInputSettings* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UInputSettings* UInputSettings::GetInputSettings()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.GetInputSettings");
|
|
|
|
UInputSettings_GetInputSettings_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.GetAxisNames
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FName> AxisNames (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UInputSettings::GetAxisNames(TArray<struct FName>* AxisNames)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.GetAxisNames");
|
|
|
|
UInputSettings_GetAxisNames_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (AxisNames != nullptr)
|
|
*AxisNames = params.AxisNames;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.GetAxisMappingByName
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InAxisName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FInputAxisKeyMapping> OutMappings (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UInputSettings::GetAxisMappingByName(const struct FName& InAxisName, TArray<struct FInputAxisKeyMapping>* OutMappings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.GetAxisMappingByName");
|
|
|
|
UInputSettings_GetAxisMappingByName_Params params;
|
|
params.InAxisName = InAxisName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutMappings != nullptr)
|
|
*OutMappings = params.OutMappings;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.GetActionNames
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TArray<struct FName> ActionNames (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UInputSettings::GetActionNames(TArray<struct FName>* ActionNames)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.GetActionNames");
|
|
|
|
UInputSettings_GetActionNames_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ActionNames != nullptr)
|
|
*ActionNames = params.ActionNames;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.GetActionMappingByName
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InActionName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FInputActionKeyMapping> OutMappings (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UInputSettings::GetActionMappingByName(const struct FName& InActionName, TArray<struct FInputActionKeyMapping>* OutMappings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.GetActionMappingByName");
|
|
|
|
UInputSettings_GetActionMappingByName_Params params;
|
|
params.InActionName = InActionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutMappings != nullptr)
|
|
*OutMappings = params.OutMappings;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.ForceRebuildKeymaps
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UInputSettings::ForceRebuildKeymaps()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.ForceRebuildKeymaps");
|
|
|
|
UInputSettings_ForceRebuildKeymaps_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.AddAxisMapping
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FInputAxisKeyMapping KeyMapping (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool bForceRebuildKeymaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputSettings::AddAxisMapping(const struct FInputAxisKeyMapping& KeyMapping, bool bForceRebuildKeymaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.AddAxisMapping");
|
|
|
|
UInputSettings_AddAxisMapping_Params params;
|
|
params.KeyMapping = KeyMapping;
|
|
params.bForceRebuildKeymaps = bForceRebuildKeymaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InputSettings.AddActionMapping
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FInputActionKeyMapping KeyMapping (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool bForceRebuildKeymaps (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInputSettings::AddActionMapping(const struct FInputActionKeyMapping& KeyMapping, bool bForceRebuildKeymaps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InputSettings.AddActionMapping");
|
|
|
|
UInputSettings_AddActionMapping_Params params;
|
|
params.KeyMapping = KeyMapping;
|
|
params.bForceRebuildKeymaps = bForceRebuildKeymaps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InterpToMovementComponent.StopSimulating
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FHitResult HitResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::StopSimulating(const struct FHitResult& HitResult)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InterpToMovementComponent.StopSimulating");
|
|
|
|
UInterpToMovementComponent_StopSimulating_Params params;
|
|
params.HitResult = HitResult;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InterpToMovementComponent.RestartMovement
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InitialDirection (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::RestartMovement(float InitialDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InterpToMovementComponent.RestartMovement");
|
|
|
|
UInterpToMovementComponent_RestartMovement_Params params;
|
|
params.InitialDirection = InitialDirection;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.InterpToMovementComponent.OnInterpToWaitEndDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::OnInterpToWaitEndDelegate__DelegateSignature(const struct FHitResult& ImpactResult, float Time)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.InterpToMovementComponent.OnInterpToWaitEndDelegate__DelegateSignature");
|
|
|
|
UInterpToMovementComponent_OnInterpToWaitEndDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
params.Time = Time;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.InterpToMovementComponent.OnInterpToWaitBeginDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::OnInterpToWaitBeginDelegate__DelegateSignature(const struct FHitResult& ImpactResult, float Time)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.InterpToMovementComponent.OnInterpToWaitBeginDelegate__DelegateSignature");
|
|
|
|
UInterpToMovementComponent_OnInterpToWaitBeginDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
params.Time = Time;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.InterpToMovementComponent.OnInterpToStopDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::OnInterpToStopDelegate__DelegateSignature(const struct FHitResult& ImpactResult, float Time)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.InterpToMovementComponent.OnInterpToStopDelegate__DelegateSignature");
|
|
|
|
UInterpToMovementComponent_OnInterpToStopDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
params.Time = Time;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.InterpToMovementComponent.OnInterpToReverseDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::OnInterpToReverseDelegate__DelegateSignature(const struct FHitResult& ImpactResult, float Time)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.InterpToMovementComponent.OnInterpToReverseDelegate__DelegateSignature");
|
|
|
|
UInterpToMovementComponent_OnInterpToReverseDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
params.Time = Time;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.InterpToMovementComponent.OnInterpToResetDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate, HasOutParms)
|
|
// Parameters:
|
|
// struct FHitResult ImpactResult (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UInterpToMovementComponent::OnInterpToResetDelegate__DelegateSignature(const struct FHitResult& ImpactResult, float Time)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.InterpToMovementComponent.OnInterpToResetDelegate__DelegateSignature");
|
|
|
|
UInterpToMovementComponent_OnInterpToResetDelegate__DelegateSignature_Params params;
|
|
params.ImpactResult = ImpactResult;
|
|
params.Time = Time;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.InterpToMovementComponent.FinaliseControlPoints
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UInterpToMovementComponent::FinaliseControlPoints()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.InterpToMovementComponent.FinaliseControlPoints");
|
|
|
|
UInterpToMovementComponent_FinaliseControlPoints_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.SetArrayPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<int> Value (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UKismetArrayLibrary::SetArrayPropertyByName(class UObject* Object, const struct FName& PropertyName, TArray<int> Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.SetArrayPropertyByName");
|
|
|
|
UKismetArrayLibrary_SetArrayPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.FilterArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class AActor*> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> FilteredArray (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UKismetArrayLibrary::FilterArray(TArray<class AActor*> TargetArray, class UClass* FilterClass, TArray<class AActor*>* FilteredArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.FilterArray");
|
|
|
|
UKismetArrayLibrary_FilterArray_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (FilteredArray != nullptr)
|
|
*FilteredArray = params.FilteredArray;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Swap
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int FirstIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int SecondIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetArrayLibrary::Array_Swap(TArray<int> TargetArray, int FirstIndex, int SecondIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Swap");
|
|
|
|
UKismetArrayLibrary_Array_Swap_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.FirstIndex = FirstIndex;
|
|
params.SecondIndex = SecondIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Shuffle
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UKismetArrayLibrary::Array_Shuffle(TArray<int> TargetArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Shuffle");
|
|
|
|
UKismetArrayLibrary_Array_Shuffle_Params params;
|
|
params.TargetArray = TargetArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Set
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Item (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool bSizeToFit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetArrayLibrary::Array_Set(TArray<int> TargetArray, int Index, int Item, bool bSizeToFit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Set");
|
|
|
|
UKismetArrayLibrary_Array_Set_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.Index = Index;
|
|
params.Item = Item;
|
|
params.bSizeToFit = bSizeToFit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Resize
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Size (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetArrayLibrary::Array_Resize(TArray<int> TargetArray, int Size)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Resize");
|
|
|
|
UKismetArrayLibrary_Array_Resize_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.Size = Size;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_RemoveItem
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Item (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetArrayLibrary::Array_RemoveItem(TArray<int> TargetArray, int Item)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_RemoveItem");
|
|
|
|
UKismetArrayLibrary_Array_RemoveItem_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.Item = Item;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Remove
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexToRemove (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetArrayLibrary::Array_Remove(TArray<int> TargetArray, int IndexToRemove)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Remove");
|
|
|
|
UKismetArrayLibrary_Array_Remove_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.IndexToRemove = IndexToRemove;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Length
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetArrayLibrary::Array_Length(TArray<int> TargetArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Length");
|
|
|
|
UKismetArrayLibrary_Array_Length_Params params;
|
|
params.TargetArray = TargetArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_LastIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetArrayLibrary::Array_LastIndex(TArray<int> TargetArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_LastIndex");
|
|
|
|
UKismetArrayLibrary_Array_LastIndex_Params params;
|
|
params.TargetArray = TargetArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_IsValidIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexToTest (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetArrayLibrary::Array_IsValidIndex(TArray<int> TargetArray, int IndexToTest)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_IsValidIndex");
|
|
|
|
UKismetArrayLibrary_Array_IsValidIndex_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.IndexToTest = IndexToTest;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Insert
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int NewItem (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetArrayLibrary::Array_Insert(TArray<int> TargetArray, int NewItem, int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Insert");
|
|
|
|
UKismetArrayLibrary_Array_Insert_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.NewItem = NewItem;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Get
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Item (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetArrayLibrary::Array_Get(TArray<int> TargetArray, int Index, int* Item)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Get");
|
|
|
|
UKismetArrayLibrary_Array_Get_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Item != nullptr)
|
|
*Item = params.Item;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Find
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int ItemToFind (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetArrayLibrary::Array_Find(TArray<int> TargetArray, int ItemToFind)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Find");
|
|
|
|
UKismetArrayLibrary_Array_Find_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.ItemToFind = ItemToFind;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Contains
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int ItemToFind (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetArrayLibrary::Array_Contains(TArray<int> TargetArray, int ItemToFind)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Contains");
|
|
|
|
UKismetArrayLibrary_Array_Contains_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.ItemToFind = ItemToFind;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Clear
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UKismetArrayLibrary::Array_Clear(TArray<int> TargetArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Clear");
|
|
|
|
UKismetArrayLibrary_Array_Clear_Params params;
|
|
params.TargetArray = TargetArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Append
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<int> SourceArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UKismetArrayLibrary::Array_Append(TArray<int> TargetArray, TArray<int> SourceArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Append");
|
|
|
|
UKismetArrayLibrary_Array_Append_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.SourceArray = SourceArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_AddUnique
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int NewItem (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetArrayLibrary::Array_AddUnique(TArray<int> TargetArray, int NewItem)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_AddUnique");
|
|
|
|
UKismetArrayLibrary_Array_AddUnique_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.NewItem = NewItem;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetArrayLibrary.Array_Add
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<int> TargetArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int NewItem (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetArrayLibrary::Array_Add(TArray<int> TargetArray, int NewItem)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetArrayLibrary.Array_Add");
|
|
|
|
UKismetArrayLibrary_Array_Add_Params params;
|
|
params.TargetArray = TargetArray;
|
|
params.NewItem = NewItem;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.Parse_StringToGuid
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString GuidString (Parm, ZeroConstructor)
|
|
// struct FGuid OutGuid (Parm, OutParm, IsPlainOldData)
|
|
// bool Success (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetGuidLibrary::Parse_StringToGuid(const struct FString& GuidString, struct FGuid* OutGuid, bool* Success)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.Parse_StringToGuid");
|
|
|
|
UKismetGuidLibrary_Parse_StringToGuid_Params params;
|
|
params.GuidString = GuidString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutGuid != nullptr)
|
|
*OutGuid = params.OutGuid;
|
|
if (Success != nullptr)
|
|
*Success = params.Success;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.NotEqual_GuidGuid
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGuid A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FGuid B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetGuidLibrary::NotEqual_GuidGuid(const struct FGuid& A, const struct FGuid& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.NotEqual_GuidGuid");
|
|
|
|
UKismetGuidLibrary_NotEqual_GuidGuid_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.NewGuid
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGuid ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FGuid UKismetGuidLibrary::NewGuid()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.NewGuid");
|
|
|
|
UKismetGuidLibrary_NewGuid_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.IsValid_Guid
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGuid InGuid (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetGuidLibrary::IsValid_Guid(const struct FGuid& InGuid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.IsValid_Guid");
|
|
|
|
UKismetGuidLibrary_IsValid_Guid_Params params;
|
|
params.InGuid = InGuid;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.Invalidate_Guid
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FGuid InGuid (Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetGuidLibrary::Invalidate_Guid(struct FGuid* InGuid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.Invalidate_Guid");
|
|
|
|
UKismetGuidLibrary_Invalidate_Guid_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (InGuid != nullptr)
|
|
*InGuid = params.InGuid;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.EqualEqual_GuidGuid
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGuid A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FGuid B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetGuidLibrary::EqualEqual_GuidGuid(const struct FGuid& A, const struct FGuid& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.EqualEqual_GuidGuid");
|
|
|
|
UKismetGuidLibrary_EqualEqual_GuidGuid_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetGuidLibrary.Conv_GuidToString
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FGuid InGuid (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetGuidLibrary::Conv_GuidToString(const struct FGuid& InGuid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetGuidLibrary.Conv_GuidToString");
|
|
|
|
UKismetGuidLibrary_Conv_GuidToString_Params params;
|
|
params.InGuid = InGuid;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_TouchForce
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetInputLibrary::PointerEvent_TouchForce(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_TouchForce");
|
|
|
|
UKismetInputLibrary_PointerEvent_TouchForce_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_IsTouchEvent
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::PointerEvent_IsTouchEvent(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_IsTouchEvent");
|
|
|
|
UKismetInputLibrary_PointerEvent_IsTouchEvent_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_IsMouseButtonDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FKey MouseButton (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::PointerEvent_IsMouseButtonDown(const struct FPointerEvent& Input, const struct FKey& MouseButton)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_IsMouseButtonDown");
|
|
|
|
UKismetInputLibrary_PointerEvent_IsMouseButtonDown_Params params;
|
|
params.Input = Input;
|
|
params.MouseButton = MouseButton;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetWheelDelta
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetInputLibrary::PointerEvent_GetWheelDelta(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetWheelDelta");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetWheelDelta_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetUserIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetInputLibrary::PointerEvent_GetUserIndex(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetUserIndex");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetUserIndex_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetTouchpadIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetInputLibrary::PointerEvent_GetTouchpadIndex(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetTouchpadIndex");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetTouchpadIndex_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetScreenSpacePosition
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetInputLibrary::PointerEvent_GetScreenSpacePosition(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetScreenSpacePosition");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetScreenSpacePosition_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetPointerIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetInputLibrary::PointerEvent_GetPointerIndex(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetPointerIndex");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetPointerIndex_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetLastScreenSpacePosition
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetInputLibrary::PointerEvent_GetLastScreenSpacePosition(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetLastScreenSpacePosition");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetLastScreenSpacePosition_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetGestureType
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// ESlateGesture ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
ESlateGesture UKismetInputLibrary::PointerEvent_GetGestureType(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetGestureType");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetGestureType_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetGestureDelta
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetInputLibrary::PointerEvent_GetGestureDelta(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetGestureDelta");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetGestureDelta_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetEffectingButton
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FKey ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FKey UKismetInputLibrary::PointerEvent_GetEffectingButton(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetEffectingButton");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetEffectingButton_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.PointerEvent_GetCursorDelta
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPointerEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetInputLibrary::PointerEvent_GetCursorDelta(const struct FPointerEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.PointerEvent_GetCursorDelta");
|
|
|
|
UKismetInputLibrary_PointerEvent_GetCursorDelta_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_IsVectorAxis
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::Key_IsVectorAxis(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_IsVectorAxis");
|
|
|
|
UKismetInputLibrary_Key_IsVectorAxis_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_IsMouseButton
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::Key_IsMouseButton(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_IsMouseButton");
|
|
|
|
UKismetInputLibrary_Key_IsMouseButton_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_IsModifierKey
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::Key_IsModifierKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_IsModifierKey");
|
|
|
|
UKismetInputLibrary_Key_IsModifierKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_IsKeyboardKey
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::Key_IsKeyboardKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_IsKeyboardKey");
|
|
|
|
UKismetInputLibrary_Key_IsKeyboardKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_IsGamepadKey
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::Key_IsGamepadKey(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_IsGamepadKey");
|
|
|
|
UKismetInputLibrary_Key_IsGamepadKey_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_IsFloatAxis
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::Key_IsFloatAxis(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_IsFloatAxis");
|
|
|
|
UKismetInputLibrary_Key_IsFloatAxis_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.Key_GetDisplayName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey Key (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetInputLibrary::Key_GetDisplayName(const struct FKey& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.Key_GetDisplayName");
|
|
|
|
UKismetInputLibrary_Key_GetDisplayName_Params params;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsShiftDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsShiftDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsShiftDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsShiftDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsRightShiftDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsRightShiftDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsRightShiftDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsRightShiftDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsRightControlDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsRightControlDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsRightControlDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsRightControlDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsRightCommandDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsRightCommandDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsRightCommandDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsRightCommandDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsRightAltDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsRightAltDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsRightAltDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsRightAltDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsRepeat
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsRepeat(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsRepeat");
|
|
|
|
UKismetInputLibrary_InputEvent_IsRepeat_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsLeftShiftDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsLeftShiftDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsLeftShiftDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsLeftShiftDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsLeftControlDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsLeftControlDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsLeftControlDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsLeftControlDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsLeftCommandDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsLeftCommandDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsLeftCommandDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsLeftCommandDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsLeftAltDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsLeftAltDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsLeftAltDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsLeftAltDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsControlDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsControlDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsControlDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsControlDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsCommandDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsCommandDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsCommandDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsCommandDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.InputEvent_IsAltDown
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::InputEvent_IsAltDown(const struct FInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.InputEvent_IsAltDown");
|
|
|
|
UKismetInputLibrary_InputEvent_IsAltDown_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.GetUserIndex
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKeyEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetInputLibrary::GetUserIndex(const struct FKeyEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.GetUserIndex");
|
|
|
|
UKismetInputLibrary_GetUserIndex_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.GetKey
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKeyEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FKey ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FKey UKismetInputLibrary::GetKey(const struct FKeyEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.GetKey");
|
|
|
|
UKismetInputLibrary_GetKey_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.GetAnalogValue
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnalogInputEvent Input (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetInputLibrary::GetAnalogValue(const struct FAnalogInputEvent& Input)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.GetAnalogValue");
|
|
|
|
UKismetInputLibrary_GetAnalogValue_Params params;
|
|
params.Input = Input;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.EqualEqual_KeyKey
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FKey A (Parm)
|
|
// struct FKey B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::EqualEqual_KeyKey(const struct FKey& A, const struct FKey& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.EqualEqual_KeyKey");
|
|
|
|
UKismetInputLibrary_EqualEqual_KeyKey_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.EqualEqual_InputChordInputChord
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FInputChord A (Parm)
|
|
// struct FInputChord B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInputLibrary::EqualEqual_InputChordInputChord(const struct FInputChord& A, const struct FInputChord& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.EqualEqual_InputChordInputChord");
|
|
|
|
UKismetInputLibrary_EqualEqual_InputChordInputChord_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInputLibrary.CalibrateTilt
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetInputLibrary::CalibrateTilt()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInputLibrary.CalibrateTilt");
|
|
|
|
UKismetInputLibrary_CalibrateTilt_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.SetCurrentLocale
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Culture (Parm, ZeroConstructor)
|
|
// bool SaveToConfig (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInternationalizationLibrary::SetCurrentLocale(const struct FString& Culture, bool SaveToConfig)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.SetCurrentLocale");
|
|
|
|
UKismetInternationalizationLibrary_SetCurrentLocale_Params params;
|
|
params.Culture = Culture;
|
|
params.SaveToConfig = SaveToConfig;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.SetCurrentLanguageAndLocale
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Culture (Parm, ZeroConstructor)
|
|
// bool SaveToConfig (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInternationalizationLibrary::SetCurrentLanguageAndLocale(const struct FString& Culture, bool SaveToConfig)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.SetCurrentLanguageAndLocale");
|
|
|
|
UKismetInternationalizationLibrary_SetCurrentLanguageAndLocale_Params params;
|
|
params.Culture = Culture;
|
|
params.SaveToConfig = SaveToConfig;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.SetCurrentLanguage
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Culture (Parm, ZeroConstructor)
|
|
// bool SaveToConfig (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInternationalizationLibrary::SetCurrentLanguage(const struct FString& Culture, bool SaveToConfig)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.SetCurrentLanguage");
|
|
|
|
UKismetInternationalizationLibrary_SetCurrentLanguage_Params params;
|
|
params.Culture = Culture;
|
|
params.SaveToConfig = SaveToConfig;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.SetCurrentCulture
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Culture (Parm, ZeroConstructor)
|
|
// bool SaveToConfig (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInternationalizationLibrary::SetCurrentCulture(const struct FString& Culture, bool SaveToConfig)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.SetCurrentCulture");
|
|
|
|
UKismetInternationalizationLibrary_SetCurrentCulture_Params params;
|
|
params.Culture = Culture;
|
|
params.SaveToConfig = SaveToConfig;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.SetCurrentAssetGroupCulture
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName AssetGroup (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Culture (Parm, ZeroConstructor)
|
|
// bool SaveToConfig (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetInternationalizationLibrary::SetCurrentAssetGroupCulture(const struct FName& AssetGroup, const struct FString& Culture, bool SaveToConfig)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.SetCurrentAssetGroupCulture");
|
|
|
|
UKismetInternationalizationLibrary_SetCurrentAssetGroupCulture_Params params;
|
|
params.AssetGroup = AssetGroup;
|
|
params.Culture = Culture;
|
|
params.SaveToConfig = SaveToConfig;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.GetCurrentLocale
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetInternationalizationLibrary::GetCurrentLocale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.GetCurrentLocale");
|
|
|
|
UKismetInternationalizationLibrary_GetCurrentLocale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.GetCurrentLanguage
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetInternationalizationLibrary::GetCurrentLanguage()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.GetCurrentLanguage");
|
|
|
|
UKismetInternationalizationLibrary_GetCurrentLanguage_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.GetCurrentCulture
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetInternationalizationLibrary::GetCurrentCulture()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.GetCurrentCulture");
|
|
|
|
UKismetInternationalizationLibrary_GetCurrentCulture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.GetCurrentAssetGroupCulture
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName AssetGroup (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetInternationalizationLibrary::GetCurrentAssetGroupCulture(const struct FName& AssetGroup)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.GetCurrentAssetGroupCulture");
|
|
|
|
UKismetInternationalizationLibrary_GetCurrentAssetGroupCulture_Params params;
|
|
params.AssetGroup = AssetGroup;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetInternationalizationLibrary.ClearCurrentAssetGroupCulture
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName AssetGroup (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool SaveToConfig (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetInternationalizationLibrary::ClearCurrentAssetGroupCulture(const struct FName& AssetGroup, bool SaveToConfig)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetInternationalizationLibrary.ClearCurrentAssetGroupCulture");
|
|
|
|
UKismetInternationalizationLibrary_ClearCurrentAssetGroupCulture_Params params;
|
|
params.AssetGroup = AssetGroup;
|
|
params.SaveToConfig = SaveToConfig;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMaterialLibrary.SetVectorParameterValue
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialParameterCollection* Collection (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ParameterValue (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetMaterialLibrary::SetVectorParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, const struct FName& ParameterName, const struct FLinearColor& ParameterValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMaterialLibrary.SetVectorParameterValue");
|
|
|
|
UKismetMaterialLibrary_SetVectorParameterValue_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Collection = Collection;
|
|
params.ParameterName = ParameterName;
|
|
params.ParameterValue = ParameterValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMaterialLibrary.SetScalarParameterValue
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialParameterCollection* Collection (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ParameterValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMaterialLibrary::SetScalarParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, const struct FName& ParameterName, float ParameterValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMaterialLibrary.SetScalarParameterValue");
|
|
|
|
UKismetMaterialLibrary_SetScalarParameterValue_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Collection = Collection;
|
|
params.ParameterName = ParameterName;
|
|
params.ParameterValue = ParameterValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMaterialLibrary.GetVectorParameterValue
|
|
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialParameterCollection* Collection (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMaterialLibrary::GetVectorParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, const struct FName& ParameterName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMaterialLibrary.GetVectorParameterValue");
|
|
|
|
UKismetMaterialLibrary_GetVectorParameterValue_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Collection = Collection;
|
|
params.ParameterName = ParameterName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMaterialLibrary.GetScalarParameterValue
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialParameterCollection* Collection (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMaterialLibrary::GetScalarParameterValue(class UObject* WorldContextObject, class UMaterialParameterCollection* Collection, const struct FName& ParameterName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMaterialLibrary.GetScalarParameterValue");
|
|
|
|
UKismetMaterialLibrary_GetScalarParameterValue_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Collection = Collection;
|
|
params.ParameterName = ParameterName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMaterialLibrary.CreateDynamicMaterialInstance
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Parent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstanceDynamic* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInstanceDynamic* UKismetMaterialLibrary::CreateDynamicMaterialInstance(class UObject* WorldContextObject, class UMaterialInterface* Parent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMaterialLibrary.CreateDynamicMaterialInstance");
|
|
|
|
UKismetMaterialLibrary_CreateDynamicMaterialInstance_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Parent = Parent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Xor_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Xor_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Xor_IntInt");
|
|
|
|
UKismetMathLibrary_Xor_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VSizeSquared
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::VSizeSquared(const struct FVector& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VSizeSquared");
|
|
|
|
UKismetMathLibrary_VSizeSquared_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VSize2DSquared
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::VSize2DSquared(const struct FVector2D& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VSize2DSquared");
|
|
|
|
UKismetMathLibrary_VSize2DSquared_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VSize2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::VSize2D(const struct FVector2D& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VSize2D");
|
|
|
|
UKismetMathLibrary_VSize2D_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VSize
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::VSize(const struct FVector& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VSize");
|
|
|
|
UKismetMathLibrary_VSize_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VLerp
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::VLerp(const struct FVector& A, const struct FVector& B, float alpha)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VLerp");
|
|
|
|
UKismetMathLibrary_VLerp_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VInterpTo_Constant
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Current (Parm, IsPlainOldData)
|
|
// struct FVector Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::VInterpTo_Constant(const struct FVector& Current, const struct FVector& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VInterpTo_Constant");
|
|
|
|
UKismetMathLibrary_VInterpTo_Constant_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VInterpTo
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Current (Parm, IsPlainOldData)
|
|
// struct FVector Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::VInterpTo(const struct FVector& Current, const struct FVector& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VInterpTo");
|
|
|
|
UKismetMathLibrary_VInterpTo_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VectorSpringInterp
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Current (Parm, IsPlainOldData)
|
|
// struct FVector Target (Parm, IsPlainOldData)
|
|
// struct FVectorSpringState SpringState (Parm, OutParm, ReferenceParm)
|
|
// float Stiffness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float CriticalDampingFactor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Mass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::VectorSpringInterp(const struct FVector& Current, const struct FVector& Target, float Mass, float Stiffness, float CriticalDampingFactor, float DeltaTime, struct FVectorSpringState* SpringState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VectorSpringInterp");
|
|
|
|
UKismetMathLibrary_VectorSpringInterp_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.Stiffness = Stiffness;
|
|
params.CriticalDampingFactor = CriticalDampingFactor;
|
|
params.DeltaTime = DeltaTime;
|
|
params.Mass = Mass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SpringState != nullptr)
|
|
*SpringState = params.SpringState;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Vector2DInterpTo_Constant
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D Current (Parm, IsPlainOldData)
|
|
// struct FVector2D Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Vector2DInterpTo_Constant(const struct FVector2D& Current, const struct FVector2D& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Vector2DInterpTo_Constant");
|
|
|
|
UKismetMathLibrary_Vector2DInterpTo_Constant_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Vector2DInterpTo
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D Current (Parm, IsPlainOldData)
|
|
// struct FVector2D Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Vector2DInterpTo(const struct FVector2D& Current, const struct FVector2D& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Vector2DInterpTo");
|
|
|
|
UKismetMathLibrary_Vector2DInterpTo_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.VEase
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EEasingFunc> EasingFunc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendExp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Steps (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::VEase(const struct FVector& A, const struct FVector& B, float alpha, TEnumAsByte<EEasingFunc> EasingFunc, float BlendExp, int Steps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.VEase");
|
|
|
|
UKismetMathLibrary_VEase_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.EasingFunc = EasingFunc;
|
|
params.BlendExp = BlendExp;
|
|
params.Steps = Steps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.UtcNow
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::UtcNow()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.UtcNow");
|
|
|
|
UKismetMathLibrary_UtcNow_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TransformRotation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::TransformRotation(const struct FTransform& T, const struct FRotator& Rotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TransformRotation");
|
|
|
|
UKismetMathLibrary_TransformRotation_Params params;
|
|
params.T = T;
|
|
params.Rotation = Rotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TransformLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::TransformLocation(const struct FTransform& T, const struct FVector& Location)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TransformLocation");
|
|
|
|
UKismetMathLibrary_TransformLocation_Params params;
|
|
params.T = T;
|
|
params.Location = Location;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TransformDirection
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Direction (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::TransformDirection(const struct FTransform& T, const struct FVector& Direction)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TransformDirection");
|
|
|
|
UKismetMathLibrary_TransformDirection_Params params;
|
|
params.T = T;
|
|
params.Direction = Direction;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Today
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::Today()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Today");
|
|
|
|
UKismetMathLibrary_Today_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TLerp
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ELerpInterpolationMode> InterpMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::TLerp(const struct FTransform& A, const struct FTransform& B, float alpha, TEnumAsByte<ELerpInterpolationMode> InterpMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TLerp");
|
|
|
|
UKismetMathLibrary_TLerp_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.InterpMode = InterpMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TInterpTo
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform Current (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform Target (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::TInterpTo(const struct FTransform& Current, const struct FTransform& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TInterpTo");
|
|
|
|
UKismetMathLibrary_TInterpTo_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TimespanZeroValue
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::TimespanZeroValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TimespanZeroValue");
|
|
|
|
UKismetMathLibrary_TimespanZeroValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TimespanRatio
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::TimespanRatio(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TimespanRatio");
|
|
|
|
UKismetMathLibrary_TimespanRatio_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TimespanMinValue
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::TimespanMinValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TimespanMinValue");
|
|
|
|
UKismetMathLibrary_TimespanMinValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TimespanMaxValue
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::TimespanMaxValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TimespanMaxValue");
|
|
|
|
UKismetMathLibrary_TimespanMaxValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TimespanFromString
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString TimespanString (Parm, ZeroConstructor)
|
|
// struct FTimespan Result (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::TimespanFromString(const struct FString& TimespanString, struct FTimespan* Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TimespanFromString");
|
|
|
|
UKismetMathLibrary_TimespanFromString_Params params;
|
|
params.TimespanString = TimespanString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Result != nullptr)
|
|
*Result = params.Result;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.TEase
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EEasingFunc> EasingFunc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendExp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Steps (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::TEase(const struct FTransform& A, const struct FTransform& B, float alpha, TEnumAsByte<EEasingFunc> EasingFunc, float BlendExp, int Steps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.TEase");
|
|
|
|
UKismetMathLibrary_TEase_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.EasingFunc = EasingFunc;
|
|
params.BlendExp = BlendExp;
|
|
params.Steps = Steps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Tan
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Tan(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Tan");
|
|
|
|
UKismetMathLibrary_Tan_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Subtract_VectorVector(const struct FVector& A, const struct FVector& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_VectorVector");
|
|
|
|
UKismetMathLibrary_Subtract_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_VectorInt
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Subtract_VectorInt(const struct FVector& A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_VectorInt");
|
|
|
|
UKismetMathLibrary_Subtract_VectorInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_VectorFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Subtract_VectorFloat(const struct FVector& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_VectorFloat");
|
|
|
|
UKismetMathLibrary_Subtract_VectorFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_Vector2DVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Subtract_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_Vector2DVector2D");
|
|
|
|
UKismetMathLibrary_Subtract_Vector2DVector2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_Vector2DFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Subtract_Vector2DFloat(const struct FVector2D& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_Vector2DFloat");
|
|
|
|
UKismetMathLibrary_Subtract_Vector2DFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::Subtract_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_Subtract_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Subtract_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_IntInt");
|
|
|
|
UKismetMathLibrary_Subtract_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Subtract_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_FloatFloat");
|
|
|
|
UKismetMathLibrary_Subtract_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_DateTimeTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::Subtract_DateTimeTimespan(const struct FDateTime& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_DateTimeTimespan");
|
|
|
|
UKismetMathLibrary_Subtract_DateTimeTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::Subtract_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_Subtract_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Subtract_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Subtract_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Subtract_ByteByte");
|
|
|
|
UKismetMathLibrary_Subtract_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Square
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Square(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Square");
|
|
|
|
UKismetMathLibrary_Square_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Sqrt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Sqrt(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Sqrt");
|
|
|
|
UKismetMathLibrary_Sqrt_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Sin
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Sin(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Sin");
|
|
|
|
UKismetMathLibrary_Sin_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SignOfInteger
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::SignOfInteger(int A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SignOfInteger");
|
|
|
|
UKismetMathLibrary_SignOfInteger_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SignOfFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::SignOfFloat(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SignOfFloat");
|
|
|
|
UKismetMathLibrary_SignOfFloat_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SetRandomStreamSeed
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRandomStream Stream (Parm, OutParm, ReferenceParm)
|
|
// int NewSeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::SetRandomStreamSeed(int NewSeed, struct FRandomStream* Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SetRandomStreamSeed");
|
|
|
|
UKismetMathLibrary_SetRandomStreamSeed_Params params;
|
|
params.NewSeed = NewSeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Stream != nullptr)
|
|
*Stream = params.Stream;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::SelectVector(const struct FVector& A, const struct FVector& B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectVector");
|
|
|
|
UKismetMathLibrary_SelectVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::SelectTransform(const struct FTransform& A, const struct FTransform& B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectTransform");
|
|
|
|
UKismetMathLibrary_SelectTransform_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString A (Parm, ZeroConstructor)
|
|
// struct FString B (Parm, ZeroConstructor)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetMathLibrary::SelectString(const struct FString& A, const struct FString& B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectString");
|
|
|
|
UKismetMathLibrary_SelectString_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::SelectRotator(const struct FRotator& A, const struct FRotator& B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectRotator");
|
|
|
|
UKismetMathLibrary_SelectRotator_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectObject
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSelectA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UObject* UKismetMathLibrary::SelectObject(class UObject* A, class UObject* B, bool bSelectA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectObject");
|
|
|
|
UKismetMathLibrary_SelectObject_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bSelectA = bSelectA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::SelectInt(int A, int B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectInt");
|
|
|
|
UKismetMathLibrary_SelectInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::SelectFloat(float A, float B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectFloat");
|
|
|
|
UKismetMathLibrary_SelectFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor A (Parm, IsPlainOldData)
|
|
// struct FLinearColor B (Parm, IsPlainOldData)
|
|
// bool bPickA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::SelectColor(const struct FLinearColor& A, const struct FLinearColor& B, bool bPickA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectColor");
|
|
|
|
UKismetMathLibrary_SelectColor_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bPickA = bPickA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SelectClass
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSelectA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UClass* UKismetMathLibrary::SelectClass(class UClass* A, class UClass* B, bool bSelectA)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SelectClass");
|
|
|
|
UKismetMathLibrary_SelectClass_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.bSelectA = bSelectA;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.SeedRandomStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRandomStream Stream (Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetMathLibrary::SeedRandomStream(struct FRandomStream* Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.SeedRandomStream");
|
|
|
|
UKismetMathLibrary_SeedRandomStream_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Stream != nullptr)
|
|
*Stream = params.Stream;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Round
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Round(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Round");
|
|
|
|
UKismetMathLibrary_Round_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RotatorFromAxisAndAngle
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Axis (Parm, IsPlainOldData)
|
|
// float angle (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::RotatorFromAxisAndAngle(const struct FVector& Axis, float angle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RotatorFromAxisAndAngle");
|
|
|
|
UKismetMathLibrary_RotatorFromAxisAndAngle_Params params;
|
|
params.Axis = Axis;
|
|
params.angle = angle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RotateAngleAxis
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVect (Parm, IsPlainOldData)
|
|
// float AngleDeg (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Axis (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RotateAngleAxis(const struct FVector& InVect, float AngleDeg, const struct FVector& Axis)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RotateAngleAxis");
|
|
|
|
UKismetMathLibrary_RotateAngleAxis_Params params;
|
|
params.InVect = InVect;
|
|
params.AngleDeg = AngleDeg;
|
|
params.Axis = Axis;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RLerp
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShortestPath (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::RLerp(const struct FRotator& A, const struct FRotator& B, float alpha, bool bShortestPath)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RLerp");
|
|
|
|
UKismetMathLibrary_RLerp_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.bShortestPath = bShortestPath;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RInterpTo_Constant
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator Current (Parm, IsPlainOldData)
|
|
// struct FRotator Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::RInterpTo_Constant(const struct FRotator& Current, const struct FRotator& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RInterpTo_Constant");
|
|
|
|
UKismetMathLibrary_RInterpTo_Constant_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RInterpTo
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator Current (Parm, IsPlainOldData)
|
|
// struct FRotator Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::RInterpTo(const struct FRotator& Current, const struct FRotator& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RInterpTo");
|
|
|
|
UKismetMathLibrary_RInterpTo_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RGBToHSV_Vector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor RGB (ConstParm, Parm, IsPlainOldData)
|
|
// struct FLinearColor HSV (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::RGBToHSV_Vector(const struct FLinearColor& RGB, struct FLinearColor* HSV)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RGBToHSV_Vector");
|
|
|
|
UKismetMathLibrary_RGBToHSV_Vector_Params params;
|
|
params.RGB = RGB;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HSV != nullptr)
|
|
*HSV = params.HSV;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RGBToHSV
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor InColor (ConstParm, Parm, IsPlainOldData)
|
|
// float H (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float S (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float V (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float A (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::RGBToHSV(const struct FLinearColor& InColor, float* H, float* S, float* V, float* A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RGBToHSV");
|
|
|
|
UKismetMathLibrary_RGBToHSV_Params params;
|
|
params.InColor = InColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (H != nullptr)
|
|
*H = params.H;
|
|
if (S != nullptr)
|
|
*S = params.S;
|
|
if (V != nullptr)
|
|
*V = params.V;
|
|
if (A != nullptr)
|
|
*A = params.A;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ResetVectorSpringState
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVectorSpringState SpringState (Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetMathLibrary::ResetVectorSpringState(struct FVectorSpringState* SpringState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ResetVectorSpringState");
|
|
|
|
UKismetMathLibrary_ResetVectorSpringState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SpringState != nullptr)
|
|
*SpringState = params.SpringState;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ResetRandomStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetMathLibrary::ResetRandomStream(const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ResetRandomStream");
|
|
|
|
UKismetMathLibrary_ResetRandomStream_Params params;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ResetFloatSpringState
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FFloatSpringState SpringState (Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetMathLibrary::ResetFloatSpringState(struct FFloatSpringState* SpringState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ResetFloatSpringState");
|
|
|
|
UKismetMathLibrary_ResetFloatSpringState_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SpringState != nullptr)
|
|
*SpringState = params.SpringState;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.REase
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShortestPath (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EEasingFunc> EasingFunc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendExp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Steps (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::REase(const struct FRotator& A, const struct FRotator& B, float alpha, bool bShortestPath, TEnumAsByte<EEasingFunc> EasingFunc, float BlendExp, int Steps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.REase");
|
|
|
|
UKismetMathLibrary_REase_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.bShortestPath = bShortestPath;
|
|
params.EasingFunc = EasingFunc;
|
|
params.BlendExp = BlendExp;
|
|
params.Steps = Steps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInRadiansFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float MaxYawInRadians (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxPitchInRadians (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInEllipticalConeInRadiansFromStream(const struct FVector& ConeDir, float MaxYawInRadians, float MaxPitchInRadians, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInRadiansFromStream");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInEllipticalConeInRadiansFromStream_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.MaxYawInRadians = MaxYawInRadians;
|
|
params.MaxPitchInRadians = MaxPitchInRadians;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInRadians
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (Parm, IsPlainOldData)
|
|
// float MaxYawInRadians (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxPitchInRadians (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInEllipticalConeInRadians(const struct FVector& ConeDir, float MaxYawInRadians, float MaxPitchInRadians)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInRadians");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInEllipticalConeInRadians_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.MaxYawInRadians = MaxYawInRadians;
|
|
params.MaxPitchInRadians = MaxPitchInRadians;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInDegreesFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float MaxYawInDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxPitchInDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInEllipticalConeInDegreesFromStream(const struct FVector& ConeDir, float MaxYawInDegrees, float MaxPitchInDegrees, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInDegreesFromStream");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInEllipticalConeInDegreesFromStream_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.MaxYawInDegrees = MaxYawInDegrees;
|
|
params.MaxPitchInDegrees = MaxPitchInDegrees;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInDegrees
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (Parm, IsPlainOldData)
|
|
// float MaxYawInDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxPitchInDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInEllipticalConeInDegrees(const struct FVector& ConeDir, float MaxYawInDegrees, float MaxPitchInDegrees)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInEllipticalConeInDegrees");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInEllipticalConeInDegrees_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.MaxYawInDegrees = MaxYawInDegrees;
|
|
params.MaxPitchInDegrees = MaxPitchInDegrees;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInConeInRadiansFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float ConeHalfAngleInRadians (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInConeInRadiansFromStream(const struct FVector& ConeDir, float ConeHalfAngleInRadians, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInConeInRadiansFromStream");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInConeInRadiansFromStream_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.ConeHalfAngleInRadians = ConeHalfAngleInRadians;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInConeInRadians
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (Parm, IsPlainOldData)
|
|
// float ConeHalfAngleInRadians (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInConeInRadians(const struct FVector& ConeDir, float ConeHalfAngleInRadians)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInConeInRadians");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInConeInRadians_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.ConeHalfAngleInRadians = ConeHalfAngleInRadians;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInConeInDegreesFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float ConeHalfAngleInDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInConeInDegreesFromStream(const struct FVector& ConeDir, float ConeHalfAngleInDegrees, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInConeInDegreesFromStream");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInConeInDegreesFromStream_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.ConeHalfAngleInDegrees = ConeHalfAngleInDegrees;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorInConeInDegrees
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ConeDir (Parm, IsPlainOldData)
|
|
// float ConeHalfAngleInDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorInConeInDegrees(const struct FVector& ConeDir, float ConeHalfAngleInDegrees)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorInConeInDegrees");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorInConeInDegrees_Params params;
|
|
params.ConeDir = ConeDir;
|
|
params.ConeHalfAngleInDegrees = ConeHalfAngleInDegrees;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVectorFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVectorFromStream(const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVectorFromStream");
|
|
|
|
UKismetMathLibrary_RandomUnitVectorFromStream_Params params;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomUnitVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomUnitVector()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomUnitVector");
|
|
|
|
UKismetMathLibrary_RandomUnitVector_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomRotatorFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool bRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::RandomRotatorFromStream(bool bRoll, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomRotatorFromStream");
|
|
|
|
UKismetMathLibrary_RandomRotatorFromStream_Params params;
|
|
params.bRoll = bRoll;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool bRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::RandomRotator(bool bRoll)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomRotator");
|
|
|
|
UKismetMathLibrary_RandomRotator_Params params;
|
|
params.bRoll = bRoll;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomPointInBoundingBox
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector BoxExtent (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::RandomPointInBoundingBox(const struct FVector& Origin, const struct FVector& BoxExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomPointInBoundingBox");
|
|
|
|
UKismetMathLibrary_RandomPointInBoundingBox_Params params;
|
|
params.Origin = Origin;
|
|
params.BoxExtent = BoxExtent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomIntegerInRangeFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::RandomIntegerInRangeFromStream(int Min, int Max, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomIntegerInRangeFromStream");
|
|
|
|
UKismetMathLibrary_RandomIntegerInRangeFromStream_Params params;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomIntegerInRange
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::RandomIntegerInRange(int Min, int Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomIntegerInRange");
|
|
|
|
UKismetMathLibrary_RandomIntegerInRange_Params params;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomIntegerFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::RandomIntegerFromStream(int Max, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomIntegerFromStream");
|
|
|
|
UKismetMathLibrary_RandomIntegerFromStream_Params params;
|
|
params.Max = Max;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomInteger
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::RandomInteger(int Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomInteger");
|
|
|
|
UKismetMathLibrary_RandomInteger_Params params;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomFloatInRangeFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::RandomFloatInRangeFromStream(float Min, float Max, const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomFloatInRangeFromStream");
|
|
|
|
UKismetMathLibrary_RandomFloatInRangeFromStream_Params params;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomFloatInRange
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::RandomFloatInRange(float Min, float Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomFloatInRange");
|
|
|
|
UKismetMathLibrary_RandomFloatInRange_Params params;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomFloatFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::RandomFloatFromStream(const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomFloatFromStream");
|
|
|
|
UKismetMathLibrary_RandomFloatFromStream_Params params;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::RandomFloat()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomFloat");
|
|
|
|
UKismetMathLibrary_RandomFloat_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomBoolWithWeightFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Weight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream RandomStream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::RandomBoolWithWeightFromStream(float Weight, const struct FRandomStream& RandomStream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomBoolWithWeightFromStream");
|
|
|
|
UKismetMathLibrary_RandomBoolWithWeightFromStream_Params params;
|
|
params.Weight = Weight;
|
|
params.RandomStream = RandomStream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomBoolWithWeight
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Weight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::RandomBoolWithWeight(float Weight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomBoolWithWeight");
|
|
|
|
UKismetMathLibrary_RandomBoolWithWeight_Params params;
|
|
params.Weight = Weight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomBoolFromStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRandomStream Stream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::RandomBoolFromStream(const struct FRandomStream& Stream)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomBoolFromStream");
|
|
|
|
UKismetMathLibrary_RandomBoolFromStream_Params params;
|
|
params.Stream = Stream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RandomBool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::RandomBool()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RandomBool");
|
|
|
|
UKismetMathLibrary_RandomBool_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.RadiansToDegrees
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::RadiansToDegrees(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.RadiansToDegrees");
|
|
|
|
UKismetMathLibrary_RadiansToDegrees_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ProjectVectorOnToVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector V (Parm, IsPlainOldData)
|
|
// struct FVector Target (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::ProjectVectorOnToVector(const struct FVector& V, const struct FVector& Target)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ProjectVectorOnToVector");
|
|
|
|
UKismetMathLibrary_ProjectVectorOnToVector_Params params;
|
|
params.V = V;
|
|
params.Target = Target;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ProjectVectorOnToPlane
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector V (Parm, IsPlainOldData)
|
|
// struct FVector PlaneNormal (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::ProjectVectorOnToPlane(const struct FVector& V, const struct FVector& PlaneNormal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ProjectVectorOnToPlane");
|
|
|
|
UKismetMathLibrary_ProjectVectorOnToPlane_Params params;
|
|
params.V = V;
|
|
params.PlaneNormal = PlaneNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ProjectPointOnToPlane
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector PlaneBase (Parm, IsPlainOldData)
|
|
// struct FVector PlaneNormal (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::ProjectPointOnToPlane(const struct FVector& Point, const struct FVector& PlaneBase, const struct FVector& PlaneNormal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ProjectPointOnToPlane");
|
|
|
|
UKismetMathLibrary_ProjectPointOnToPlane_Params params;
|
|
params.Point = Point;
|
|
params.PlaneBase = PlaneBase;
|
|
params.PlaneNormal = PlaneNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.PointsAreCoplanar
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<struct FVector> Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// float Tolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::PointsAreCoplanar(TArray<struct FVector> Points, float Tolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.PointsAreCoplanar");
|
|
|
|
UKismetMathLibrary_PointsAreCoplanar_Params params;
|
|
params.Points = Points;
|
|
params.Tolerance = Tolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Percent_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Percent_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Percent_IntInt");
|
|
|
|
UKismetMathLibrary_Percent_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Percent_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Percent_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Percent_FloatFloat");
|
|
|
|
UKismetMathLibrary_Percent_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Percent_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Percent_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Percent_ByteByte");
|
|
|
|
UKismetMathLibrary_Percent_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Or_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Or_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Or_IntInt");
|
|
|
|
UKismetMathLibrary_Or_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Now
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::Now()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Now");
|
|
|
|
UKismetMathLibrary_Now_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_VectorVector(const struct FVector& A, const struct FVector& B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_VectorVector");
|
|
|
|
UKismetMathLibrary_NotEqual_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_Vector2DVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_Vector2DVector2D");
|
|
|
|
UKismetMathLibrary_NotEqual_Vector2DVector2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_NotEqual_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_RotatorRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_RotatorRotator(const struct FRotator& A, const struct FRotator& B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_RotatorRotator");
|
|
|
|
UKismetMathLibrary_NotEqual_RotatorRotator_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_ObjectObject
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_ObjectObject(class UObject* A, class UObject* B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_ObjectObject");
|
|
|
|
UKismetMathLibrary_NotEqual_ObjectObject_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_NameName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_NameName(const struct FName& A, const struct FName& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_NameName");
|
|
|
|
UKismetMathLibrary_NotEqual_NameName_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_IntInt");
|
|
|
|
UKismetMathLibrary_NotEqual_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_FloatFloat");
|
|
|
|
UKismetMathLibrary_NotEqual_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_NotEqual_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_ClassClass
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_ClassClass(class UClass* A, class UClass* B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_ClassClass");
|
|
|
|
UKismetMathLibrary_NotEqual_ClassClass_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_ByteByte");
|
|
|
|
UKismetMathLibrary_NotEqual_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NotEqual_BoolBool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NotEqual_BoolBool(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NotEqual_BoolBool");
|
|
|
|
UKismetMathLibrary_NotEqual_BoolBool_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Not_PreBool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Not_PreBool(bool A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Not_PreBool");
|
|
|
|
UKismetMathLibrary_Not_PreBool_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Not_Int
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Not_Int(int A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Not_Int");
|
|
|
|
UKismetMathLibrary_Not_Int_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NormalizeToRange
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float RangeMin (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float RangeMax (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::NormalizeToRange(float Value, float RangeMin, float RangeMax)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NormalizeToRange");
|
|
|
|
UKismetMathLibrary_NormalizeToRange_Params params;
|
|
params.Value = Value;
|
|
params.RangeMin = RangeMin;
|
|
params.RangeMax = RangeMax;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NormalizedDeltaRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::NormalizedDeltaRotator(const struct FRotator& A, const struct FRotator& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NormalizedDeltaRotator");
|
|
|
|
UKismetMathLibrary_NormalizedDeltaRotator_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NormalizeAxis
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float angle (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::NormalizeAxis(float angle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NormalizeAxis");
|
|
|
|
UKismetMathLibrary_NormalizeAxis_Params params;
|
|
params.angle = angle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Normal2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Normal2D(const struct FVector2D& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Normal2D");
|
|
|
|
UKismetMathLibrary_Normal2D_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Normal
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Normal(const struct FVector& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Normal");
|
|
|
|
UKismetMathLibrary_Normal_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NegateVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::NegateVector(const struct FVector& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NegateVector");
|
|
|
|
UKismetMathLibrary_NegateVector_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NegateRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::NegateRotator(const struct FRotator& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NegateRotator");
|
|
|
|
UKismetMathLibrary_NegateRotator_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NearlyEqual_TransformTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float LocationTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float RotationTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Scale3DTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NearlyEqual_TransformTransform(const struct FTransform& A, const struct FTransform& B, float LocationTolerance, float RotationTolerance, float Scale3DTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NearlyEqual_TransformTransform");
|
|
|
|
UKismetMathLibrary_NearlyEqual_TransformTransform_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.LocationTolerance = LocationTolerance;
|
|
params.RotationTolerance = RotationTolerance;
|
|
params.Scale3DTolerance = Scale3DTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.NearlyEqual_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::NearlyEqual_FloatFloat(float A, float B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.NearlyEqual_FloatFloat");
|
|
|
|
UKismetMathLibrary_NearlyEqual_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MultiplyMultiply_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Base (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Exp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::MultiplyMultiply_FloatFloat(float Base, float Exp)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MultiplyMultiply_FloatFloat");
|
|
|
|
UKismetMathLibrary_MultiplyMultiply_FloatFloat_Params params;
|
|
params.Base = Base;
|
|
params.Exp = Exp;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MultiplyByPi
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::MultiplyByPi(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MultiplyByPi");
|
|
|
|
UKismetMathLibrary_MultiplyByPi_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Multiply_VectorVector(const struct FVector& A, const struct FVector& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_VectorVector");
|
|
|
|
UKismetMathLibrary_Multiply_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_VectorInt
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Multiply_VectorInt(const struct FVector& A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_VectorInt");
|
|
|
|
UKismetMathLibrary_Multiply_VectorInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_VectorFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Multiply_VectorFloat(const struct FVector& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_VectorFloat");
|
|
|
|
UKismetMathLibrary_Multiply_VectorFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_Vector2DVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Multiply_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_Vector2DVector2D");
|
|
|
|
UKismetMathLibrary_Multiply_Vector2DVector2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_Vector2DFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Multiply_Vector2DFloat(const struct FVector2D& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_Vector2DFloat");
|
|
|
|
UKismetMathLibrary_Multiply_Vector2DFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_TimespanFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float Scalar (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::Multiply_TimespanFloat(const struct FTimespan& A, float Scalar)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_TimespanFloat");
|
|
|
|
UKismetMathLibrary_Multiply_TimespanFloat_Params params;
|
|
params.A = A;
|
|
params.Scalar = Scalar;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_RotatorInt
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::Multiply_RotatorInt(const struct FRotator& A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_RotatorInt");
|
|
|
|
UKismetMathLibrary_Multiply_RotatorInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_RotatorFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::Multiply_RotatorFloat(const struct FRotator& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_RotatorFloat");
|
|
|
|
UKismetMathLibrary_Multiply_RotatorFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_LinearColorLinearColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor A (Parm, IsPlainOldData)
|
|
// struct FLinearColor B (Parm, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::Multiply_LinearColorLinearColor(const struct FLinearColor& A, const struct FLinearColor& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_LinearColorLinearColor");
|
|
|
|
UKismetMathLibrary_Multiply_LinearColorLinearColor_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_LinearColorFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::Multiply_LinearColorFloat(const struct FLinearColor& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_LinearColorFloat");
|
|
|
|
UKismetMathLibrary_Multiply_LinearColorFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Multiply_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_IntInt");
|
|
|
|
UKismetMathLibrary_Multiply_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_IntFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Multiply_IntFloat(int A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_IntFloat");
|
|
|
|
UKismetMathLibrary_Multiply_IntFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Multiply_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_FloatFloat");
|
|
|
|
UKismetMathLibrary_Multiply_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Multiply_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Multiply_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Multiply_ByteByte");
|
|
|
|
UKismetMathLibrary_Multiply_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MirrorVectorByNormal
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVect (Parm, IsPlainOldData)
|
|
// struct FVector InNormal (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::MirrorVectorByNormal(const struct FVector& InVect, const struct FVector& InNormal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MirrorVectorByNormal");
|
|
|
|
UKismetMathLibrary_MirrorVectorByNormal_Params params;
|
|
params.InVect = InVect;
|
|
params.InNormal = InNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MinOfIntArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> IntArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexOfMinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int MinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MinOfIntArray(TArray<int> IntArray, int* IndexOfMinValue, int* MinValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MinOfIntArray");
|
|
|
|
UKismetMathLibrary_MinOfIntArray_Params params;
|
|
params.IntArray = IntArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (IndexOfMinValue != nullptr)
|
|
*IndexOfMinValue = params.IndexOfMinValue;
|
|
if (MinValue != nullptr)
|
|
*MinValue = params.MinValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MinOfFloatArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<float> FloatArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexOfMinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float MinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MinOfFloatArray(TArray<float> FloatArray, int* IndexOfMinValue, float* MinValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MinOfFloatArray");
|
|
|
|
UKismetMathLibrary_MinOfFloatArray_Params params;
|
|
params.FloatArray = FloatArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (IndexOfMinValue != nullptr)
|
|
*IndexOfMinValue = params.IndexOfMinValue;
|
|
if (MinValue != nullptr)
|
|
*MinValue = params.MinValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MinOfByteArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<unsigned char> ByteArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexOfMinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char MinValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MinOfByteArray(TArray<unsigned char> ByteArray, int* IndexOfMinValue, unsigned char* MinValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MinOfByteArray");
|
|
|
|
UKismetMathLibrary_MinOfByteArray_Params params;
|
|
params.ByteArray = ByteArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (IndexOfMinValue != nullptr)
|
|
*IndexOfMinValue = params.IndexOfMinValue;
|
|
if (MinValue != nullptr)
|
|
*MinValue = params.MinValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MinimumAreaRectangle
|
|
// (Final, BlueprintAuthorityOnly, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FVector> InVerts (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// struct FVector SampleSurfaceNormal (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector OutRectCenter (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator OutRectRotation (Parm, OutParm, IsPlainOldData)
|
|
// float OutSideLengthX (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float OutSideLengthY (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// bool bDebugDraw (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MinimumAreaRectangle(class UObject* WorldContextObject, TArray<struct FVector> InVerts, const struct FVector& SampleSurfaceNormal, bool bDebugDraw, struct FVector* OutRectCenter, float* OutSideLengthX, float* OutSideLengthY, struct FRotator* OutRectRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MinimumAreaRectangle");
|
|
|
|
UKismetMathLibrary_MinimumAreaRectangle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InVerts = InVerts;
|
|
params.SampleSurfaceNormal = SampleSurfaceNormal;
|
|
params.bDebugDraw = bDebugDraw;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutRectCenter != nullptr)
|
|
*OutRectCenter = params.OutRectCenter;
|
|
if (OutRectRotation != nullptr)
|
|
*OutRectRotation = params.OutRectRotation;
|
|
if (OutSideLengthX != nullptr)
|
|
*OutSideLengthX = params.OutSideLengthX;
|
|
if (OutSideLengthY != nullptr)
|
|
*OutSideLengthY = params.OutSideLengthY;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Min
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Min(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Min");
|
|
|
|
UKismetMathLibrary_Min_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MaxOfIntArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<int> IntArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexOfMaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int MaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MaxOfIntArray(TArray<int> IntArray, int* IndexOfMaxValue, int* MaxValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MaxOfIntArray");
|
|
|
|
UKismetMathLibrary_MaxOfIntArray_Params params;
|
|
params.IntArray = IntArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (IndexOfMaxValue != nullptr)
|
|
*IndexOfMaxValue = params.IndexOfMaxValue;
|
|
if (MaxValue != nullptr)
|
|
*MaxValue = params.MaxValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MaxOfFloatArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<float> FloatArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexOfMaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MaxOfFloatArray(TArray<float> FloatArray, int* IndexOfMaxValue, float* MaxValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MaxOfFloatArray");
|
|
|
|
UKismetMathLibrary_MaxOfFloatArray_Params params;
|
|
params.FloatArray = FloatArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (IndexOfMaxValue != nullptr)
|
|
*IndexOfMaxValue = params.IndexOfMaxValue;
|
|
if (MaxValue != nullptr)
|
|
*MaxValue = params.MaxValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MaxOfByteArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<unsigned char> ByteArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// int IndexOfMaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char MaxValue (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::MaxOfByteArray(TArray<unsigned char> ByteArray, int* IndexOfMaxValue, unsigned char* MaxValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MaxOfByteArray");
|
|
|
|
UKismetMathLibrary_MaxOfByteArray_Params params;
|
|
params.ByteArray = ByteArray;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (IndexOfMaxValue != nullptr)
|
|
*IndexOfMaxValue = params.IndexOfMaxValue;
|
|
if (MaxValue != nullptr)
|
|
*MaxValue = params.MaxValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Max
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Max(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Max");
|
|
|
|
UKismetMathLibrary_Max_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MapRangeUnclamped
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InRangeA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InRangeB (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutRangeA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutRangeB (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::MapRangeUnclamped(float Value, float InRangeA, float InRangeB, float OutRangeA, float OutRangeB)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MapRangeUnclamped");
|
|
|
|
UKismetMathLibrary_MapRangeUnclamped_Params params;
|
|
params.Value = Value;
|
|
params.InRangeA = InRangeA;
|
|
params.InRangeB = InRangeB;
|
|
params.OutRangeA = OutRangeA;
|
|
params.OutRangeB = OutRangeB;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MapRangeClamped
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InRangeA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InRangeB (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutRangeA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OutRangeB (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::MapRangeClamped(float Value, float InRangeA, float InRangeB, float OutRangeA, float OutRangeB)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MapRangeClamped");
|
|
|
|
UKismetMathLibrary_MapRangeClamped_Params params;
|
|
params.Value = Value;
|
|
params.InRangeA = InRangeA;
|
|
params.InRangeB = InRangeB;
|
|
params.OutRangeA = OutRangeA;
|
|
params.OutRangeB = OutRangeB;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float X (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Y (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::MakeVector2D(float X, float Y)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeVector2D");
|
|
|
|
UKismetMathLibrary_MakeVector2D_Params params;
|
|
params.X = X;
|
|
params.Y = Y;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float X (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Y (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Z (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::MakeVector(float X, float Y, float Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeVector");
|
|
|
|
UKismetMathLibrary_MakeVector_Params params;
|
|
params.X = X;
|
|
params.Y = Y;
|
|
params.Z = Z;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeTransform
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// struct FVector Scale (Parm, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::MakeTransform(const struct FVector& Location, const struct FRotator& Rotation, const struct FVector& Scale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeTransform");
|
|
|
|
UKismetMathLibrary_MakeTransform_Params params;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
params.Scale = Scale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeTimespan2
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Days (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Hours (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Minutes (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Seconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int FractionNano (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::MakeTimespan2(int Days, int Hours, int Minutes, int Seconds, int FractionNano)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeTimespan2");
|
|
|
|
UKismetMathLibrary_MakeTimespan2_Params params;
|
|
params.Days = Days;
|
|
params.Hours = Hours;
|
|
params.Minutes = Minutes;
|
|
params.Seconds = Seconds;
|
|
params.FractionNano = FractionNano;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Days (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Hours (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Minutes (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Seconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Milliseconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::MakeTimespan(int Days, int Hours, int Minutes, int Seconds, int Milliseconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeTimespan");
|
|
|
|
UKismetMathLibrary_MakeTimespan_Params params;
|
|
params.Days = Days;
|
|
params.Hours = Hours;
|
|
params.Minutes = Minutes;
|
|
params.Seconds = Seconds;
|
|
params.Milliseconds = Milliseconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromZY
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Z (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Y (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromZY(const struct FVector& Z, const struct FVector& Y)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromZY");
|
|
|
|
UKismetMathLibrary_MakeRotFromZY_Params params;
|
|
params.Z = Z;
|
|
params.Y = Y;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromZX
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Z (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector X (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromZX(const struct FVector& Z, const struct FVector& X)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromZX");
|
|
|
|
UKismetMathLibrary_MakeRotFromZX_Params params;
|
|
params.Z = Z;
|
|
params.X = X;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromZ
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Z (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromZ(const struct FVector& Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromZ");
|
|
|
|
UKismetMathLibrary_MakeRotFromZ_Params params;
|
|
params.Z = Z;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromYZ
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Y (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Z (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromYZ(const struct FVector& Y, const struct FVector& Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromYZ");
|
|
|
|
UKismetMathLibrary_MakeRotFromYZ_Params params;
|
|
params.Y = Y;
|
|
params.Z = Z;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromYX
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Y (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector X (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromYX(const struct FVector& Y, const struct FVector& X)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromYX");
|
|
|
|
UKismetMathLibrary_MakeRotFromYX_Params params;
|
|
params.Y = Y;
|
|
params.X = X;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromY
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Y (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromY(const struct FVector& Y)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromY");
|
|
|
|
UKismetMathLibrary_MakeRotFromY_Params params;
|
|
params.Y = Y;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromXZ
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector X (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Z (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromXZ(const struct FVector& X, const struct FVector& Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromXZ");
|
|
|
|
UKismetMathLibrary_MakeRotFromXZ_Params params;
|
|
params.X = X;
|
|
params.Z = Z;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromXY
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector X (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Y (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromXY(const struct FVector& X, const struct FVector& Y)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromXY");
|
|
|
|
UKismetMathLibrary_MakeRotFromXY_Params params;
|
|
params.X = X;
|
|
params.Y = Y;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotFromX
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector X (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotFromX(const struct FVector& X)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotFromX");
|
|
|
|
UKismetMathLibrary_MakeRotFromX_Params params;
|
|
params.X = X;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Roll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Pitch (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Yaw (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotator(float Roll, float Pitch, float Yaw)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotator");
|
|
|
|
UKismetMathLibrary_MakeRotator_Params params;
|
|
params.Roll = Roll;
|
|
params.Pitch = Pitch;
|
|
params.Yaw = Yaw;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRotationFromAxes
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Forward (Parm, IsPlainOldData)
|
|
// struct FVector Right (Parm, IsPlainOldData)
|
|
// struct FVector Up (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::MakeRotationFromAxes(const struct FVector& Forward, const struct FVector& Right, const struct FVector& Up)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRotationFromAxes");
|
|
|
|
UKismetMathLibrary_MakeRotationFromAxes_Params params;
|
|
params.Forward = Forward;
|
|
params.Right = Right;
|
|
params.Up = Up;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeRandomStream
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int InitialSeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRandomStream ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FRandomStream UKismetMathLibrary::MakeRandomStream(int InitialSeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeRandomStream");
|
|
|
|
UKismetMathLibrary_MakeRandomStream_Params params;
|
|
params.InitialSeed = InitialSeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakePulsatingValue
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float InCurrentTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPulsesPerSecond (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InPhase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::MakePulsatingValue(float InCurrentTime, float InPulsesPerSecond, float InPhase)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakePulsatingValue");
|
|
|
|
UKismetMathLibrary_MakePulsatingValue_Params params;
|
|
params.InCurrentTime = InCurrentTime;
|
|
params.InPulsesPerSecond = InPulsesPerSecond;
|
|
params.InPhase = InPhase;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakePlaneFromPointAndNormal
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector Normal (Parm, IsPlainOldData)
|
|
// struct FPlane ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FPlane UKismetMathLibrary::MakePlaneFromPointAndNormal(const struct FVector& Point, const struct FVector& Normal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakePlaneFromPointAndNormal");
|
|
|
|
UKismetMathLibrary_MakePlaneFromPointAndNormal_Params params;
|
|
params.Point = Point;
|
|
params.Normal = Normal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Year (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Month (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Day (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Hour (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Minute (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Second (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Millisecond (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::MakeDateTime(int Year, int Month, int Day, int Hour, int Minute, int Second, int Millisecond)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeDateTime");
|
|
|
|
UKismetMathLibrary_MakeDateTime_Params params;
|
|
params.Year = Year;
|
|
params.Month = Month;
|
|
params.Day = Day;
|
|
params.Hour = Hour;
|
|
params.Minute = Minute;
|
|
params.Second = Second;
|
|
params.Millisecond = Millisecond;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float R (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float G (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::MakeColor(float R, float G, float B, float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeColor");
|
|
|
|
UKismetMathLibrary_MakeColor_Params params;
|
|
params.R = R;
|
|
params.G = G;
|
|
params.B = B;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeBox2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D Min (Parm, IsPlainOldData)
|
|
// struct FVector2D Max (Parm, IsPlainOldData)
|
|
// struct FBox2D ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FBox2D UKismetMathLibrary::MakeBox2D(const struct FVector2D& Min, const struct FVector2D& Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeBox2D");
|
|
|
|
UKismetMathLibrary_MakeBox2D_Params params;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.MakeBox
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Min (Parm, IsPlainOldData)
|
|
// struct FVector Max (Parm, IsPlainOldData)
|
|
// struct FBox ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FBox UKismetMathLibrary::MakeBox(const struct FVector& Min, const struct FVector& Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.MakeBox");
|
|
|
|
UKismetMathLibrary_MakeBox_Params params;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Loge
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Loge(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Loge");
|
|
|
|
UKismetMathLibrary_Loge_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Log
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Base (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Log(float A, float Base)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Log");
|
|
|
|
UKismetMathLibrary_Log_Params params;
|
|
params.A = A;
|
|
params.Base = Base;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LinePlaneIntersection_OriginNormal
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector LineStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector LineEnd (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector PlaneOrigin (Parm, IsPlainOldData)
|
|
// struct FVector PlaneNormal (Parm, IsPlainOldData)
|
|
// float T (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Intersection (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LinePlaneIntersection_OriginNormal(const struct FVector& LineStart, const struct FVector& LineEnd, const struct FVector& PlaneOrigin, const struct FVector& PlaneNormal, float* T, struct FVector* Intersection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LinePlaneIntersection_OriginNormal");
|
|
|
|
UKismetMathLibrary_LinePlaneIntersection_OriginNormal_Params params;
|
|
params.LineStart = LineStart;
|
|
params.LineEnd = LineEnd;
|
|
params.PlaneOrigin = PlaneOrigin;
|
|
params.PlaneNormal = PlaneNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (T != nullptr)
|
|
*T = params.T;
|
|
if (Intersection != nullptr)
|
|
*Intersection = params.Intersection;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LinePlaneIntersection
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector LineStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector LineEnd (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FPlane APlane (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float T (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Intersection (Parm, OutParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LinePlaneIntersection(const struct FVector& LineStart, const struct FVector& LineEnd, const struct FPlane& APlane, float* T, struct FVector* Intersection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LinePlaneIntersection");
|
|
|
|
UKismetMathLibrary_LinePlaneIntersection_Params params;
|
|
params.LineStart = LineStart;
|
|
params.LineEnd = LineEnd;
|
|
params.APlane = APlane;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (T != nullptr)
|
|
*T = params.T;
|
|
if (Intersection != nullptr)
|
|
*Intersection = params.Intersection;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LinearColorLerpUsingHSV
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor A (Parm, IsPlainOldData)
|
|
// struct FLinearColor B (Parm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::LinearColorLerpUsingHSV(const struct FLinearColor& A, const struct FLinearColor& B, float alpha)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LinearColorLerpUsingHSV");
|
|
|
|
UKismetMathLibrary_LinearColorLerpUsingHSV_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LinearColorLerp
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor A (Parm, IsPlainOldData)
|
|
// struct FLinearColor B (Parm, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::LinearColorLerp(const struct FLinearColor& A, const struct FLinearColor& B, float alpha)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LinearColorLerp");
|
|
|
|
UKismetMathLibrary_LinearColorLerp_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LessLess_VectorRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::LessLess_VectorRotator(const struct FVector& A, const struct FRotator& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LessLess_VectorRotator");
|
|
|
|
UKismetMathLibrary_LessLess_VectorRotator_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LessEqual_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LessEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LessEqual_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_LessEqual_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LessEqual_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LessEqual_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LessEqual_IntInt");
|
|
|
|
UKismetMathLibrary_LessEqual_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LessEqual_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LessEqual_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LessEqual_FloatFloat");
|
|
|
|
UKismetMathLibrary_LessEqual_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LessEqual_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LessEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LessEqual_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_LessEqual_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.LessEqual_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::LessEqual_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.LessEqual_ByteByte");
|
|
|
|
UKismetMathLibrary_LessEqual_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Less_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Less_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Less_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_Less_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Less_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Less_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Less_IntInt");
|
|
|
|
UKismetMathLibrary_Less_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Less_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Less_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Less_FloatFloat");
|
|
|
|
UKismetMathLibrary_Less_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Less_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Less_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Less_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_Less_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Less_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Less_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Less_ByteByte");
|
|
|
|
UKismetMathLibrary_Less_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Lerp
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Lerp(float A, float B, float alpha)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Lerp");
|
|
|
|
UKismetMathLibrary_Lerp_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.IsPointInBoxWithTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FTransform BoxWorldTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::IsPointInBoxWithTransform(const struct FVector& Point, const struct FTransform& BoxWorldTransform, const struct FVector& BoxExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.IsPointInBoxWithTransform");
|
|
|
|
UKismetMathLibrary_IsPointInBoxWithTransform_Params params;
|
|
params.Point = Point;
|
|
params.BoxWorldTransform = BoxWorldTransform;
|
|
params.BoxExtent = BoxExtent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.IsPointInBox
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector BoxOrigin (Parm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::IsPointInBox(const struct FVector& Point, const struct FVector& BoxOrigin, const struct FVector& BoxExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.IsPointInBox");
|
|
|
|
UKismetMathLibrary_IsPointInBox_Params params;
|
|
params.Point = Point;
|
|
params.BoxOrigin = BoxOrigin;
|
|
params.BoxExtent = BoxExtent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.IsMorning
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::IsMorning(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.IsMorning");
|
|
|
|
UKismetMathLibrary_IsMorning_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.IsLeapYear
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Year (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::IsLeapYear(int Year)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.IsLeapYear");
|
|
|
|
UKismetMathLibrary_IsLeapYear_Params params;
|
|
params.Year = Year;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.IsAfternoon
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::IsAfternoon(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.IsAfternoon");
|
|
|
|
UKismetMathLibrary_IsAfternoon_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InvertTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::InvertTransform(const struct FTransform& T)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InvertTransform");
|
|
|
|
UKismetMathLibrary_InvertTransform_Params params;
|
|
params.T = T;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InverseTransformRotation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::InverseTransformRotation(const struct FTransform& T, const struct FRotator& Rotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InverseTransformRotation");
|
|
|
|
UKismetMathLibrary_InverseTransformRotation_Params params;
|
|
params.T = T;
|
|
params.Rotation = Rotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InverseTransformLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::InverseTransformLocation(const struct FTransform& T, const struct FVector& Location)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InverseTransformLocation");
|
|
|
|
UKismetMathLibrary_InverseTransformLocation_Params params;
|
|
params.T = T;
|
|
params.Location = Location;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InverseTransformDirection
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform T (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Direction (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::InverseTransformDirection(const struct FTransform& T, const struct FVector& Direction)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InverseTransformDirection");
|
|
|
|
UKismetMathLibrary_InverseTransformDirection_Params params;
|
|
params.T = T;
|
|
params.Direction = Direction;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InverseLerp
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::InverseLerp(float A, float B, float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InverseLerp");
|
|
|
|
UKismetMathLibrary_InverseLerp_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InRange_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InclusiveMin (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InclusiveMax (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::InRange_IntInt(int Value, int Min, int Max, bool InclusiveMin, bool InclusiveMax)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InRange_IntInt");
|
|
|
|
UKismetMathLibrary_InRange_IntInt_Params params;
|
|
params.Value = Value;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
params.InclusiveMin = InclusiveMin;
|
|
params.InclusiveMax = InclusiveMax;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.InRange_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InclusiveMin (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool InclusiveMax (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::InRange_FloatFloat(float Value, float Min, float Max, bool InclusiveMin, bool InclusiveMax)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.InRange_FloatFloat");
|
|
|
|
UKismetMathLibrary_InRange_FloatFloat_Params params;
|
|
params.Value = Value;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
params.InclusiveMin = InclusiveMin;
|
|
params.InclusiveMax = InclusiveMax;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Hypotenuse
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Hypotenuse(float Width, float Height)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Hypotenuse");
|
|
|
|
UKismetMathLibrary_Hypotenuse_Params params;
|
|
params.Width = Width;
|
|
params.Height = Height;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.HSVToRGB_Vector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor HSV (ConstParm, Parm, IsPlainOldData)
|
|
// struct FLinearColor RGB (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::HSVToRGB_Vector(const struct FLinearColor& HSV, struct FLinearColor* RGB)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.HSVToRGB_Vector");
|
|
|
|
UKismetMathLibrary_HSVToRGB_Vector_Params params;
|
|
params.HSV = HSV;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (RGB != nullptr)
|
|
*RGB = params.RGB;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.HSVToRGB
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float H (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float S (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float V (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::HSVToRGB(float H, float S, float V, float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.HSVToRGB");
|
|
|
|
UKismetMathLibrary_HSVToRGB_Params params;
|
|
params.H = H;
|
|
params.S = S;
|
|
params.V = V;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GridSnap_Float
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Location (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float GridSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GridSnap_Float(float Location, float GridSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GridSnap_Float");
|
|
|
|
UKismetMathLibrary_GridSnap_Float_Params params;
|
|
params.Location = Location;
|
|
params.GridSize = GridSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GreaterGreater_VectorRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GreaterGreater_VectorRotator(const struct FVector& A, const struct FRotator& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GreaterGreater_VectorRotator");
|
|
|
|
UKismetMathLibrary_GreaterGreater_VectorRotator_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GreaterEqual_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::GreaterEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GreaterEqual_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_GreaterEqual_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GreaterEqual_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::GreaterEqual_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GreaterEqual_IntInt");
|
|
|
|
UKismetMathLibrary_GreaterEqual_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GreaterEqual_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::GreaterEqual_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GreaterEqual_FloatFloat");
|
|
|
|
UKismetMathLibrary_GreaterEqual_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GreaterEqual_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::GreaterEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GreaterEqual_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_GreaterEqual_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GreaterEqual_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::GreaterEqual_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GreaterEqual_ByteByte");
|
|
|
|
UKismetMathLibrary_GreaterEqual_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Greater_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Greater_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Greater_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_Greater_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Greater_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Greater_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Greater_IntInt");
|
|
|
|
UKismetMathLibrary_Greater_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Greater_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Greater_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Greater_FloatFloat");
|
|
|
|
UKismetMathLibrary_Greater_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Greater_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Greater_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Greater_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_Greater_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Greater_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Greater_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Greater_ByteByte");
|
|
|
|
UKismetMathLibrary_Greater_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetYear
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetYear(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetYear");
|
|
|
|
UKismetMathLibrary_GetYear_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetYawPitchFromVector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVec (Parm, IsPlainOldData)
|
|
// float Yaw (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Pitch (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::GetYawPitchFromVector(const struct FVector& InVec, float* Yaw, float* Pitch)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetYawPitchFromVector");
|
|
|
|
UKismetMathLibrary_GetYawPitchFromVector_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Yaw != nullptr)
|
|
*Yaw = params.Yaw;
|
|
if (Pitch != nullptr)
|
|
*Pitch = params.Pitch;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetVectorArrayAverage
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<struct FVector> Vectors (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GetVectorArrayAverage(TArray<struct FVector> Vectors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetVectorArrayAverage");
|
|
|
|
UKismetMathLibrary_GetVectorArrayAverage_Params params;
|
|
params.Vectors = Vectors;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetUpVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GetUpVector(const struct FRotator& InRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetUpVector");
|
|
|
|
UKismetMathLibrary_GetUpVector_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTotalSeconds
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetTotalSeconds(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTotalSeconds");
|
|
|
|
UKismetMathLibrary_GetTotalSeconds_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTotalMinutes
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetTotalMinutes(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTotalMinutes");
|
|
|
|
UKismetMathLibrary_GetTotalMinutes_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTotalMilliseconds
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetTotalMilliseconds(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTotalMilliseconds");
|
|
|
|
UKismetMathLibrary_GetTotalMilliseconds_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTotalHours
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetTotalHours(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTotalHours");
|
|
|
|
UKismetMathLibrary_GetTotalHours_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTotalDays
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetTotalDays(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTotalDays");
|
|
|
|
UKismetMathLibrary_GetTotalDays_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTimeOfDay
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::GetTimeOfDay(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTimeOfDay");
|
|
|
|
UKismetMathLibrary_GetTimeOfDay_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetTAU
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetTAU()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetTAU");
|
|
|
|
UKismetMathLibrary_GetTAU_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetSeconds
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetSeconds(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetSeconds");
|
|
|
|
UKismetMathLibrary_GetSeconds_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetSecond
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetSecond(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetSecond");
|
|
|
|
UKismetMathLibrary_GetSecond_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetRightVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GetRightVector(const struct FRotator& InRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetRightVector");
|
|
|
|
UKismetMathLibrary_GetRightVector_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetReflectionVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Direction (Parm, IsPlainOldData)
|
|
// struct FVector SurfaceNormal (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GetReflectionVector(const struct FVector& Direction, const struct FVector& SurfaceNormal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetReflectionVector");
|
|
|
|
UKismetMathLibrary_GetReflectionVector_Params params;
|
|
params.Direction = Direction;
|
|
params.SurfaceNormal = SurfaceNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetPointDistanceToSegment
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector SegmentStart (Parm, IsPlainOldData)
|
|
// struct FVector SegmentEnd (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetPointDistanceToSegment(const struct FVector& Point, const struct FVector& SegmentStart, const struct FVector& SegmentEnd)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetPointDistanceToSegment");
|
|
|
|
UKismetMathLibrary_GetPointDistanceToSegment_Params params;
|
|
params.Point = Point;
|
|
params.SegmentStart = SegmentStart;
|
|
params.SegmentEnd = SegmentEnd;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetPointDistanceToLine
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector LineOrigin (Parm, IsPlainOldData)
|
|
// struct FVector LineDirection (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetPointDistanceToLine(const struct FVector& Point, const struct FVector& LineOrigin, const struct FVector& LineDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetPointDistanceToLine");
|
|
|
|
UKismetMathLibrary_GetPointDistanceToLine_Params params;
|
|
params.Point = Point;
|
|
params.LineOrigin = LineOrigin;
|
|
params.LineDirection = LineDirection;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetPI
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetPI()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetPI");
|
|
|
|
UKismetMathLibrary_GetPI_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMonth
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetMonth(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMonth");
|
|
|
|
UKismetMathLibrary_GetMonth_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMinutes
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetMinutes(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMinutes");
|
|
|
|
UKismetMathLibrary_GetMinutes_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMinute
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetMinute(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMinute");
|
|
|
|
UKismetMathLibrary_GetMinute_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMinElement
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetMinElement(const struct FVector& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMinElement");
|
|
|
|
UKismetMathLibrary_GetMinElement_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMilliseconds
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetMilliseconds(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMilliseconds");
|
|
|
|
UKismetMathLibrary_GetMilliseconds_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMillisecond
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetMillisecond(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMillisecond");
|
|
|
|
UKismetMathLibrary_GetMillisecond_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetMaxElement
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::GetMaxElement(const struct FVector& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetMaxElement");
|
|
|
|
UKismetMathLibrary_GetMaxElement_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetHours
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetHours(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetHours");
|
|
|
|
UKismetMathLibrary_GetHours_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetHour12
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetHour12(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetHour12");
|
|
|
|
UKismetMathLibrary_GetHour12_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetHour
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetHour(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetHour");
|
|
|
|
UKismetMathLibrary_GetHour_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetForwardVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GetForwardVector(const struct FRotator& InRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetForwardVector");
|
|
|
|
UKismetMathLibrary_GetForwardVector_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetDuration
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::GetDuration(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetDuration");
|
|
|
|
UKismetMathLibrary_GetDuration_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetDirectionUnitVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector From (Parm, IsPlainOldData)
|
|
// struct FVector To (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::GetDirectionUnitVector(const struct FVector& From, const struct FVector& To)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetDirectionUnitVector");
|
|
|
|
UKismetMathLibrary_GetDirectionUnitVector_Params params;
|
|
params.From = From;
|
|
params.To = To;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetDays
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetDays(const struct FTimespan& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetDays");
|
|
|
|
UKismetMathLibrary_GetDays_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetDayOfYear
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetDayOfYear(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetDayOfYear");
|
|
|
|
UKismetMathLibrary_GetDayOfYear_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetDay
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::GetDay(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetDay");
|
|
|
|
UKismetMathLibrary_GetDay_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetDate
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::GetDate(const struct FDateTime& A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetDate");
|
|
|
|
UKismetMathLibrary_GetDate_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetAzimuthAndElevation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InDirection (Parm, IsPlainOldData)
|
|
// struct FTransform ReferenceFrame (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Azimuth (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Elevation (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::GetAzimuthAndElevation(const struct FVector& InDirection, const struct FTransform& ReferenceFrame, float* Azimuth, float* Elevation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetAzimuthAndElevation");
|
|
|
|
UKismetMathLibrary_GetAzimuthAndElevation_Params params;
|
|
params.InDirection = InDirection;
|
|
params.ReferenceFrame = ReferenceFrame;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Azimuth != nullptr)
|
|
*Azimuth = params.Azimuth;
|
|
if (Elevation != nullptr)
|
|
*Elevation = params.Elevation;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.GetAxes
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FVector X (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Y (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Z (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::GetAxes(const struct FRotator& A, struct FVector* X, struct FVector* Y, struct FVector* Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.GetAxes");
|
|
|
|
UKismetMathLibrary_GetAxes_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (X != nullptr)
|
|
*X = params.X;
|
|
if (Y != nullptr)
|
|
*Y = params.Y;
|
|
if (Z != nullptr)
|
|
*Z = params.Z;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FTruncVector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVector (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FIntVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntVector UKismetMathLibrary::FTruncVector(const struct FVector& InVector)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FTruncVector");
|
|
|
|
UKismetMathLibrary_FTruncVector_Params params;
|
|
params.InVector = InVector;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FTrunc
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::FTrunc(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FTrunc");
|
|
|
|
UKismetMathLibrary_FTrunc_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FromSeconds
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Seconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::FromSeconds(float Seconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FromSeconds");
|
|
|
|
UKismetMathLibrary_FromSeconds_Params params;
|
|
params.Seconds = Seconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FromMinutes
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Minutes (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::FromMinutes(float Minutes)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FromMinutes");
|
|
|
|
UKismetMathLibrary_FromMinutes_Params params;
|
|
params.Minutes = Minutes;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FromMilliseconds
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Milliseconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::FromMilliseconds(float Milliseconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FromMilliseconds");
|
|
|
|
UKismetMathLibrary_FromMilliseconds_Params params;
|
|
params.Milliseconds = Milliseconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FromHours
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Hours (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::FromHours(float Hours)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FromHours");
|
|
|
|
UKismetMathLibrary_FromHours_Params params;
|
|
params.Hours = Hours;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FromDays
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Days (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::FromDays(float Days)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FromDays");
|
|
|
|
UKismetMathLibrary_FromDays_Params params;
|
|
params.Days = Days;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Fraction
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Fraction(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Fraction");
|
|
|
|
UKismetMathLibrary_Fraction_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FMod
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Dividend (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Divisor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Remainder (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::FMod(float Dividend, float Divisor, float* Remainder)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FMod");
|
|
|
|
UKismetMathLibrary_FMod_Params params;
|
|
params.Dividend = Dividend;
|
|
params.Divisor = Divisor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Remainder != nullptr)
|
|
*Remainder = params.Remainder;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FMin
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FMin(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FMin");
|
|
|
|
UKismetMathLibrary_FMin_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FMax
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FMax(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FMax");
|
|
|
|
UKismetMathLibrary_FMax_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FloatSpringInterp
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// float Current (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FFloatSpringState SpringState (Parm, OutParm, ReferenceParm)
|
|
// float Stiffness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float CriticalDampingFactor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Mass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FloatSpringInterp(float Current, float Target, float Mass, float Stiffness, float CriticalDampingFactor, float DeltaTime, struct FFloatSpringState* SpringState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FloatSpringInterp");
|
|
|
|
UKismetMathLibrary_FloatSpringInterp_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.Stiffness = Stiffness;
|
|
params.CriticalDampingFactor = CriticalDampingFactor;
|
|
params.DeltaTime = DeltaTime;
|
|
params.Mass = Mass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SpringState != nullptr)
|
|
*SpringState = params.SpringState;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FixedTurn
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float InCurrent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InDesired (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InDeltaRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FixedTurn(float InCurrent, float InDesired, float InDeltaRate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FixedTurn");
|
|
|
|
UKismetMathLibrary_FixedTurn_Params params;
|
|
params.InCurrent = InCurrent;
|
|
params.InDesired = InDesired;
|
|
params.InDeltaRate = InDeltaRate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FInterpTo_Constant
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Current (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FInterpTo_Constant(float Current, float Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FInterpTo_Constant");
|
|
|
|
UKismetMathLibrary_FInterpTo_Constant_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FInterpTo
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Current (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Target (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FInterpTo(float Current, float Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FInterpTo");
|
|
|
|
UKismetMathLibrary_FInterpTo_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FInterpEaseInOut
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Exponent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FInterpEaseInOut(float A, float B, float alpha, float Exponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FInterpEaseInOut");
|
|
|
|
UKismetMathLibrary_FInterpEaseInOut_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.Exponent = Exponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FindNearestPointsOnLineSegments
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Segment1Start (Parm, IsPlainOldData)
|
|
// struct FVector Segment1End (Parm, IsPlainOldData)
|
|
// struct FVector Segment2Start (Parm, IsPlainOldData)
|
|
// struct FVector Segment2End (Parm, IsPlainOldData)
|
|
// struct FVector Segment1Point (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Segment2Point (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::FindNearestPointsOnLineSegments(const struct FVector& Segment1Start, const struct FVector& Segment1End, const struct FVector& Segment2Start, const struct FVector& Segment2End, struct FVector* Segment1Point, struct FVector* Segment2Point)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FindNearestPointsOnLineSegments");
|
|
|
|
UKismetMathLibrary_FindNearestPointsOnLineSegments_Params params;
|
|
params.Segment1Start = Segment1Start;
|
|
params.Segment1End = Segment1End;
|
|
params.Segment2Start = Segment2Start;
|
|
params.Segment2End = Segment2End;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Segment1Point != nullptr)
|
|
*Segment1Point = params.Segment1Point;
|
|
if (Segment2Point != nullptr)
|
|
*Segment2Point = params.Segment2Point;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FindLookAtRotation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Start (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Target (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::FindLookAtRotation(const struct FVector& Start, const struct FVector& Target)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FindLookAtRotation");
|
|
|
|
UKismetMathLibrary_FindLookAtRotation_Params params;
|
|
params.Start = Start;
|
|
params.Target = Target;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FindClosestPointOnSegment
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector SegmentStart (Parm, IsPlainOldData)
|
|
// struct FVector SegmentEnd (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::FindClosestPointOnSegment(const struct FVector& Point, const struct FVector& SegmentStart, const struct FVector& SegmentEnd)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FindClosestPointOnSegment");
|
|
|
|
UKismetMathLibrary_FindClosestPointOnSegment_Params params;
|
|
params.Point = Point;
|
|
params.SegmentStart = SegmentStart;
|
|
params.SegmentEnd = SegmentEnd;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FindClosestPointOnLine
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Point (Parm, IsPlainOldData)
|
|
// struct FVector LineOrigin (Parm, IsPlainOldData)
|
|
// struct FVector LineDirection (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::FindClosestPointOnLine(const struct FVector& Point, const struct FVector& LineOrigin, const struct FVector& LineDirection)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FindClosestPointOnLine");
|
|
|
|
UKismetMathLibrary_FindClosestPointOnLine_Params params;
|
|
params.Point = Point;
|
|
params.LineOrigin = LineOrigin;
|
|
params.LineDirection = LineDirection;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FFloor
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::FFloor(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FFloor");
|
|
|
|
UKismetMathLibrary_FFloor_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FClamp
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::FClamp(float Value, float Min, float Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FClamp");
|
|
|
|
UKismetMathLibrary_FClamp_Params params;
|
|
params.Value = Value;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.FCeil
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::FCeil(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.FCeil");
|
|
|
|
UKismetMathLibrary_FCeil_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Exp
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Exp(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Exp");
|
|
|
|
UKismetMathLibrary_Exp_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_VectorVector(const struct FVector& A, const struct FVector& B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_VectorVector");
|
|
|
|
UKismetMathLibrary_EqualEqual_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_Vector2DVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_Vector2DVector2D");
|
|
|
|
UKismetMathLibrary_EqualEqual_Vector2DVector2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_TransformTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_TransformTransform(const struct FTransform& A, const struct FTransform& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_TransformTransform");
|
|
|
|
UKismetMathLibrary_EqualEqual_TransformTransform_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_EqualEqual_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_RotatorRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// float ErrorTolerance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_RotatorRotator(const struct FRotator& A, const struct FRotator& B, float ErrorTolerance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_RotatorRotator");
|
|
|
|
UKismetMathLibrary_EqualEqual_RotatorRotator_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.ErrorTolerance = ErrorTolerance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_ObjectObject
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_ObjectObject(class UObject* A, class UObject* B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_ObjectObject");
|
|
|
|
UKismetMathLibrary_EqualEqual_ObjectObject_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_NameName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_NameName(const struct FName& A, const struct FName& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_NameName");
|
|
|
|
UKismetMathLibrary_EqualEqual_NameName_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_IntInt");
|
|
|
|
UKismetMathLibrary_EqualEqual_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_FloatFloat");
|
|
|
|
UKismetMathLibrary_EqualEqual_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_DateTimeDateTime
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FDateTime B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_DateTimeDateTime(const struct FDateTime& A, const struct FDateTime& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_DateTimeDateTime");
|
|
|
|
UKismetMathLibrary_EqualEqual_DateTimeDateTime_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_ClassClass
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_ClassClass(class UClass* A, class UClass* B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_ClassClass");
|
|
|
|
UKismetMathLibrary_EqualEqual_ClassClass_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_ByteByte");
|
|
|
|
UKismetMathLibrary_EqualEqual_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.EqualEqual_BoolBool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::EqualEqual_BoolBool(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.EqualEqual_BoolBool");
|
|
|
|
UKismetMathLibrary_EqualEqual_BoolBool_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Ease
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EEasingFunc> EasingFunc (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BlendExp (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Steps (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Ease(float A, float B, float alpha, TEnumAsByte<EEasingFunc> EasingFunc, float BlendExp, int Steps)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Ease");
|
|
|
|
UKismetMathLibrary_Ease_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
params.alpha = alpha;
|
|
params.EasingFunc = EasingFunc;
|
|
params.BlendExp = BlendExp;
|
|
params.Steps = Steps;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DotProduct2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DotProduct2D(const struct FVector2D& A, const struct FVector2D& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DotProduct2D");
|
|
|
|
UKismetMathLibrary_DotProduct2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Dot_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Dot_VectorVector(const struct FVector& A, const struct FVector& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Dot_VectorVector");
|
|
|
|
UKismetMathLibrary_Dot_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Divide_VectorVector(const struct FVector& A, const struct FVector& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_VectorVector");
|
|
|
|
UKismetMathLibrary_Divide_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_VectorInt
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Divide_VectorInt(const struct FVector& A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_VectorInt");
|
|
|
|
UKismetMathLibrary_Divide_VectorInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_VectorFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Divide_VectorFloat(const struct FVector& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_VectorFloat");
|
|
|
|
UKismetMathLibrary_Divide_VectorFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_Vector2DVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Divide_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_Vector2DVector2D");
|
|
|
|
UKismetMathLibrary_Divide_Vector2DVector2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_Vector2DFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Divide_Vector2DFloat(const struct FVector2D& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_Vector2DFloat");
|
|
|
|
UKismetMathLibrary_Divide_Vector2DFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_TimespanFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// float Scalar (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::Divide_TimespanFloat(const struct FTimespan& A, float Scalar)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_TimespanFloat");
|
|
|
|
UKismetMathLibrary_Divide_TimespanFloat_Params params;
|
|
params.A = A;
|
|
params.Scalar = Scalar;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Divide_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_IntInt");
|
|
|
|
UKismetMathLibrary_Divide_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Divide_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_FloatFloat");
|
|
|
|
UKismetMathLibrary_Divide_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Divide_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Divide_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Divide_ByteByte");
|
|
|
|
UKismetMathLibrary_Divide_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegTan
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegTan(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegTan");
|
|
|
|
UKismetMathLibrary_DegTan_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegSin
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegSin(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegSin");
|
|
|
|
UKismetMathLibrary_DegSin_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegreesToRadians
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegreesToRadians(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegreesToRadians");
|
|
|
|
UKismetMathLibrary_DegreesToRadians_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegCos
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegCos(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegCos");
|
|
|
|
UKismetMathLibrary_DegCos_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegAtan2
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegAtan2(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegAtan2");
|
|
|
|
UKismetMathLibrary_DegAtan2_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegAtan
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegAtan(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegAtan");
|
|
|
|
UKismetMathLibrary_DegAtan_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegAsin
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegAsin(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegAsin");
|
|
|
|
UKismetMathLibrary_DegAsin_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DegAcos
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::DegAcos(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DegAcos");
|
|
|
|
UKismetMathLibrary_DegAcos_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DaysInYear
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Year (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::DaysInYear(int Year)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DaysInYear");
|
|
|
|
UKismetMathLibrary_DaysInYear_Params params;
|
|
params.Year = Year;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DaysInMonth
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Year (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Month (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::DaysInMonth(int Year, int Month)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DaysInMonth");
|
|
|
|
UKismetMathLibrary_DaysInMonth_Params params;
|
|
params.Year = Year;
|
|
params.Month = Month;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DateTimeMinValue
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::DateTimeMinValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DateTimeMinValue");
|
|
|
|
UKismetMathLibrary_DateTimeMinValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DateTimeMaxValue
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::DateTimeMaxValue()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DateTimeMaxValue");
|
|
|
|
UKismetMathLibrary_DateTimeMaxValue_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DateTimeFromString
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString DateTimeString (Parm, ZeroConstructor)
|
|
// struct FDateTime Result (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::DateTimeFromString(const struct FString& DateTimeString, struct FDateTime* Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DateTimeFromString");
|
|
|
|
UKismetMathLibrary_DateTimeFromString_Params params;
|
|
params.DateTimeString = DateTimeString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Result != nullptr)
|
|
*Result = params.Result;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.DateTimeFromIsoString
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString IsoString (Parm, ZeroConstructor)
|
|
// struct FDateTime Result (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::DateTimeFromIsoString(const struct FString& IsoString, struct FDateTime* Result)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.DateTimeFromIsoString");
|
|
|
|
UKismetMathLibrary_DateTimeFromIsoString_Params params;
|
|
params.IsoString = IsoString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Result != nullptr)
|
|
*Result = params.Result;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.CrossProduct2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::CrossProduct2D(const struct FVector2D& A, const struct FVector2D& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.CrossProduct2D");
|
|
|
|
UKismetMathLibrary_CrossProduct2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Cross_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Cross_VectorVector(const struct FVector& A, const struct FVector& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Cross_VectorVector");
|
|
|
|
UKismetMathLibrary_Cross_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.CreateVectorFromYawPitch
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Yaw (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Pitch (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Length (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::CreateVectorFromYawPitch(float Yaw, float Pitch, float Length)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.CreateVectorFromYawPitch");
|
|
|
|
UKismetMathLibrary_CreateVectorFromYawPitch_Params params;
|
|
params.Yaw = Yaw;
|
|
params.Pitch = Pitch;
|
|
params.Length = Length;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Cos
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Cos(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Cos");
|
|
|
|
UKismetMathLibrary_Cos_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ConvertTransformToRelative
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform Transform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform ParentTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::ConvertTransformToRelative(const struct FTransform& Transform, const struct FTransform& ParentTransform)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ConvertTransformToRelative");
|
|
|
|
UKismetMathLibrary_ConvertTransformToRelative_Params params;
|
|
params.Transform = Transform;
|
|
params.ParentTransform = ParentTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_VectorToVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVector (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Conv_VectorToVector2D(const struct FVector& InVector)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_VectorToVector2D");
|
|
|
|
UKismetMathLibrary_Conv_VectorToVector2D_Params params;
|
|
params.InVector = InVector;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_VectorToTransform
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InLocation (Parm, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::Conv_VectorToTransform(const struct FVector& InLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_VectorToTransform");
|
|
|
|
UKismetMathLibrary_Conv_VectorToTransform_Params params;
|
|
params.InLocation = InLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_VectorToRotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVec (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::Conv_VectorToRotator(const struct FVector& InVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_VectorToRotator");
|
|
|
|
UKismetMathLibrary_Conv_VectorToRotator_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_VectorToLinearColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVec (Parm, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::Conv_VectorToLinearColor(const struct FVector& InVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_VectorToLinearColor");
|
|
|
|
UKismetMathLibrary_Conv_VectorToLinearColor_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_Vector2DToVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D InVector2D (Parm, IsPlainOldData)
|
|
// float Z (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Conv_Vector2DToVector(const struct FVector2D& InVector2D, float Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_Vector2DToVector");
|
|
|
|
UKismetMathLibrary_Conv_Vector2DToVector_Params params;
|
|
params.InVector2D = InVector2D;
|
|
params.Z = Z;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_RotatorToVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Conv_RotatorToVector(const struct FRotator& InRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_RotatorToVector");
|
|
|
|
UKismetMathLibrary_Conv_RotatorToVector_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_LinearColorToVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor InLinearColor (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Conv_LinearColorToVector(const struct FLinearColor& InLinearColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_LinearColorToVector");
|
|
|
|
UKismetMathLibrary_Conv_LinearColorToVector_Params params;
|
|
params.InLinearColor = InLinearColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_LinearColorToColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor InLinearColor (Parm, IsPlainOldData)
|
|
// struct FColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FColor UKismetMathLibrary::Conv_LinearColorToColor(const struct FLinearColor& InLinearColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_LinearColorToColor");
|
|
|
|
UKismetMathLibrary_Conv_LinearColorToColor_Params params;
|
|
params.InLinearColor = InLinearColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_IntVectorToVector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FIntVector InIntVector (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Conv_IntVectorToVector(const struct FIntVector& InIntVector)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_IntVectorToVector");
|
|
|
|
UKismetMathLibrary_Conv_IntVectorToVector_Params params;
|
|
params.InIntVector = InIntVector;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_IntToIntVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FIntVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FIntVector UKismetMathLibrary::Conv_IntToIntVector(int inInt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_IntToIntVector");
|
|
|
|
UKismetMathLibrary_Conv_IntToIntVector_Params params;
|
|
params.inInt = inInt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_IntToFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Conv_IntToFloat(int inInt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_IntToFloat");
|
|
|
|
UKismetMathLibrary_Conv_IntToFloat_Params params;
|
|
params.inInt = inInt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_IntToByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Conv_IntToByte(int inInt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_IntToByte");
|
|
|
|
UKismetMathLibrary_Conv_IntToByte_Params params;
|
|
params.inInt = inInt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_IntToBool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::Conv_IntToBool(int inInt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_IntToBool");
|
|
|
|
UKismetMathLibrary_Conv_IntToBool_Params params;
|
|
params.inInt = inInt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_FloatToVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float InFloat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Conv_FloatToVector(float InFloat)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_FloatToVector");
|
|
|
|
UKismetMathLibrary_Conv_FloatToVector_Params params;
|
|
params.InFloat = InFloat;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_FloatToLinearColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float InFloat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::Conv_FloatToLinearColor(float InFloat)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_FloatToLinearColor");
|
|
|
|
UKismetMathLibrary_Conv_FloatToLinearColor_Params params;
|
|
params.InFloat = InFloat;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_ColorToLinearColor
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FColor InColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::Conv_ColorToLinearColor(const struct FColor& InColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_ColorToLinearColor");
|
|
|
|
UKismetMathLibrary_Conv_ColorToLinearColor_Params params;
|
|
params.InColor = InColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_ByteToInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char InByte (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Conv_ByteToInt(unsigned char InByte)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_ByteToInt");
|
|
|
|
UKismetMathLibrary_Conv_ByteToInt_Params params;
|
|
params.InByte = InByte;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_ByteToFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char InByte (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Conv_ByteToFloat(unsigned char InByte)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_ByteToFloat");
|
|
|
|
UKismetMathLibrary_Conv_ByteToFloat_Params params;
|
|
params.InByte = InByte;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_BoolToInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Conv_BoolToInt(bool InBool)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_BoolToInt");
|
|
|
|
UKismetMathLibrary_Conv_BoolToInt_Params params;
|
|
params.InBool = InBool;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_BoolToFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Conv_BoolToFloat(bool InBool)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_BoolToFloat");
|
|
|
|
UKismetMathLibrary_Conv_BoolToFloat_Params params;
|
|
params.InBool = InBool;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Conv_BoolToByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Conv_BoolToByte(bool InBool)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Conv_BoolToByte");
|
|
|
|
UKismetMathLibrary_Conv_BoolToByte_Params params;
|
|
params.InBool = InBool;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ComposeTransforms
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform A (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform B (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UKismetMathLibrary::ComposeTransforms(const struct FTransform& A, const struct FTransform& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ComposeTransforms");
|
|
|
|
UKismetMathLibrary_ComposeTransforms_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ComposeRotators
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator A (Parm, IsPlainOldData)
|
|
// struct FRotator B (Parm, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UKismetMathLibrary::ComposeRotators(const struct FRotator& A, const struct FRotator& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ComposeRotators");
|
|
|
|
UKismetMathLibrary_ComposeRotators_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ClassIsChildOf
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* TestClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* ParentClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::ClassIsChildOf(class UClass* TestClass, class UClass* ParentClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ClassIsChildOf");
|
|
|
|
UKismetMathLibrary_ClassIsChildOf_Params params;
|
|
params.TestClass = TestClass;
|
|
params.ParentClass = ParentClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ClampVectorSize
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::ClampVectorSize(const struct FVector& A, float Min, float Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ClampVectorSize");
|
|
|
|
UKismetMathLibrary_ClampVectorSize_Params params;
|
|
params.A = A;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ClampAxis
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float angle (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::ClampAxis(float angle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ClampAxis");
|
|
|
|
UKismetMathLibrary_ClampAxis_Params params;
|
|
params.angle = angle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.ClampAngle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float AngleDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MinAngleDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float MaxAngleDegrees (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::ClampAngle(float AngleDegrees, float MinAngleDegrees, float MaxAngleDegrees)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.ClampAngle");
|
|
|
|
UKismetMathLibrary_ClampAngle_Params params;
|
|
params.AngleDegrees = AngleDegrees;
|
|
params.MinAngleDegrees = MinAngleDegrees;
|
|
params.MaxAngleDegrees = MaxAngleDegrees;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Clamp
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Min (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Max (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Clamp(int Value, int Min, int Max)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Clamp");
|
|
|
|
UKismetMathLibrary_Clamp_Params params;
|
|
params.Value = Value;
|
|
params.Min = Min;
|
|
params.Max = Max;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.CInterpTo
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor Current (Parm, IsPlainOldData)
|
|
// struct FLinearColor Target (Parm, IsPlainOldData)
|
|
// float DeltaTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InterpSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UKismetMathLibrary::CInterpTo(const struct FLinearColor& Current, const struct FLinearColor& Target, float DeltaTime, float InterpSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.CInterpTo");
|
|
|
|
UKismetMathLibrary_CInterpTo_Params params;
|
|
params.Current = Current;
|
|
params.Target = Target;
|
|
params.DeltaTime = DeltaTime;
|
|
params.InterpSpeed = InterpSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakVector2D
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D InVec (Parm, IsPlainOldData)
|
|
// float X (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Y (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakVector2D(const struct FVector2D& InVec, float* X, float* Y)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakVector2D");
|
|
|
|
UKismetMathLibrary_BreakVector2D_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (X != nullptr)
|
|
*X = params.X;
|
|
if (Y != nullptr)
|
|
*Y = params.Y;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakVector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVec (Parm, IsPlainOldData)
|
|
// float X (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Y (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Z (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakVector(const struct FVector& InVec, float* X, float* Y, float* Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakVector");
|
|
|
|
UKismetMathLibrary_BreakVector_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (X != nullptr)
|
|
*X = params.X;
|
|
if (Y != nullptr)
|
|
*Y = params.Y;
|
|
if (Z != nullptr)
|
|
*Z = params.Z;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform InTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Location (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Scale (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakTransform(const struct FTransform& InTransform, struct FVector* Location, struct FRotator* Rotation, struct FVector* Scale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakTransform");
|
|
|
|
UKismetMathLibrary_BreakTransform_Params params;
|
|
params.InTransform = InTransform;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Location != nullptr)
|
|
*Location = params.Location;
|
|
if (Rotation != nullptr)
|
|
*Rotation = params.Rotation;
|
|
if (Scale != nullptr)
|
|
*Scale = params.Scale;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakTimespan2
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan InTimespan (Parm)
|
|
// int Days (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Hours (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Minutes (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Seconds (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int FractionNano (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakTimespan2(const struct FTimespan& InTimespan, int* Days, int* Hours, int* Minutes, int* Seconds, int* FractionNano)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakTimespan2");
|
|
|
|
UKismetMathLibrary_BreakTimespan2_Params params;
|
|
params.InTimespan = InTimespan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Days != nullptr)
|
|
*Days = params.Days;
|
|
if (Hours != nullptr)
|
|
*Hours = params.Hours;
|
|
if (Minutes != nullptr)
|
|
*Minutes = params.Minutes;
|
|
if (Seconds != nullptr)
|
|
*Seconds = params.Seconds;
|
|
if (FractionNano != nullptr)
|
|
*FractionNano = params.FractionNano;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakTimespan
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan InTimespan (Parm)
|
|
// int Days (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Hours (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Minutes (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Seconds (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Milliseconds (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakTimespan(const struct FTimespan& InTimespan, int* Days, int* Hours, int* Minutes, int* Seconds, int* Milliseconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakTimespan");
|
|
|
|
UKismetMathLibrary_BreakTimespan_Params params;
|
|
params.InTimespan = InTimespan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Days != nullptr)
|
|
*Days = params.Days;
|
|
if (Hours != nullptr)
|
|
*Hours = params.Hours;
|
|
if (Minutes != nullptr)
|
|
*Minutes = params.Minutes;
|
|
if (Seconds != nullptr)
|
|
*Seconds = params.Seconds;
|
|
if (Milliseconds != nullptr)
|
|
*Milliseconds = params.Milliseconds;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakRotIntoAxes
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector X (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Y (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Z (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakRotIntoAxes(const struct FRotator& InRot, struct FVector* X, struct FVector* Y, struct FVector* Z)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakRotIntoAxes");
|
|
|
|
UKismetMathLibrary_BreakRotIntoAxes_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (X != nullptr)
|
|
*X = params.X;
|
|
if (Y != nullptr)
|
|
*Y = params.Y;
|
|
if (Z != nullptr)
|
|
*Z = params.Z;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakRotator
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// float Roll (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Pitch (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float Yaw (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakRotator(const struct FRotator& InRot, float* Roll, float* Pitch, float* Yaw)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakRotator");
|
|
|
|
UKismetMathLibrary_BreakRotator_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Roll != nullptr)
|
|
*Roll = params.Roll;
|
|
if (Pitch != nullptr)
|
|
*Pitch = params.Pitch;
|
|
if (Yaw != nullptr)
|
|
*Yaw = params.Yaw;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakRandomStream
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRandomStream InRandomStream (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// int InitialSeed (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakRandomStream(const struct FRandomStream& InRandomStream, int* InitialSeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakRandomStream");
|
|
|
|
UKismetMathLibrary_BreakRandomStream_Params params;
|
|
params.InRandomStream = InRandomStream;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (InitialSeed != nullptr)
|
|
*InitialSeed = params.InitialSeed;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakDateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime InDateTime (Parm)
|
|
// int Year (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Month (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Day (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Hour (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Minute (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Second (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Millisecond (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakDateTime(const struct FDateTime& InDateTime, int* Year, int* Month, int* Day, int* Hour, int* Minute, int* Second, int* Millisecond)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakDateTime");
|
|
|
|
UKismetMathLibrary_BreakDateTime_Params params;
|
|
params.InDateTime = InDateTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Year != nullptr)
|
|
*Year = params.Year;
|
|
if (Month != nullptr)
|
|
*Month = params.Month;
|
|
if (Day != nullptr)
|
|
*Day = params.Day;
|
|
if (Hour != nullptr)
|
|
*Hour = params.Hour;
|
|
if (Minute != nullptr)
|
|
*Minute = params.Minute;
|
|
if (Second != nullptr)
|
|
*Second = params.Second;
|
|
if (Millisecond != nullptr)
|
|
*Millisecond = params.Millisecond;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BreakColor
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor InColor (ConstParm, Parm, IsPlainOldData)
|
|
// float R (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float G (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// float A (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetMathLibrary::BreakColor(const struct FLinearColor& InColor, float* R, float* G, float* B, float* A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BreakColor");
|
|
|
|
UKismetMathLibrary_BreakColor_Params params;
|
|
params.InColor = InColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (R != nullptr)
|
|
*R = params.R;
|
|
if (G != nullptr)
|
|
*G = params.G;
|
|
if (B != nullptr)
|
|
*B = params.B;
|
|
if (A != nullptr)
|
|
*A = params.A;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BooleanXOR
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::BooleanXOR(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BooleanXOR");
|
|
|
|
UKismetMathLibrary_BooleanXOR_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BooleanOR
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::BooleanOR(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BooleanOR");
|
|
|
|
UKismetMathLibrary_BooleanOR_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BooleanNOR
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::BooleanNOR(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BooleanNOR");
|
|
|
|
UKismetMathLibrary_BooleanNOR_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BooleanNAND
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::BooleanNAND(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BooleanNAND");
|
|
|
|
UKismetMathLibrary_BooleanNAND_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BooleanAND
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetMathLibrary::BooleanAND(bool A, bool B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BooleanAND");
|
|
|
|
UKismetMathLibrary_BooleanAND_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BMin
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::BMin(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BMin");
|
|
|
|
UKismetMathLibrary_BMin_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.BMax
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::BMax(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.BMax");
|
|
|
|
UKismetMathLibrary_BMax_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Atan2
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Atan2(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Atan2");
|
|
|
|
UKismetMathLibrary_Atan2_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Atan
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Atan(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Atan");
|
|
|
|
UKismetMathLibrary_Atan_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Asin
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Asin(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Asin");
|
|
|
|
UKismetMathLibrary_Asin_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.And_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::And_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.And_IntInt");
|
|
|
|
UKismetMathLibrary_And_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_VectorVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// struct FVector B (Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Add_VectorVector(const struct FVector& A, const struct FVector& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_VectorVector");
|
|
|
|
UKismetMathLibrary_Add_VectorVector_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_VectorInt
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Add_VectorInt(const struct FVector& A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_VectorInt");
|
|
|
|
UKismetMathLibrary_Add_VectorInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_VectorFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UKismetMathLibrary::Add_VectorFloat(const struct FVector& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_VectorFloat");
|
|
|
|
UKismetMathLibrary_Add_VectorFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_Vector2DVector2D
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// struct FVector2D B (Parm, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Add_Vector2DVector2D(const struct FVector2D& A, const struct FVector2D& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_Vector2DVector2D");
|
|
|
|
UKismetMathLibrary_Add_Vector2DVector2D_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_Vector2DFloat
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D A (Parm, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UKismetMathLibrary::Add_Vector2DFloat(const struct FVector2D& A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_Vector2DFloat");
|
|
|
|
UKismetMathLibrary_Add_Vector2DFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_TimespanTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// struct FTimespan ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimespan UKismetMathLibrary::Add_TimespanTimespan(const struct FTimespan& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_TimespanTimespan");
|
|
|
|
UKismetMathLibrary_Add_TimespanTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_IntInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Add_IntInt(int A, int B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_IntInt");
|
|
|
|
UKismetMathLibrary_Add_IntInt_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_FloatFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Add_FloatFloat(float A, float B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_FloatFloat");
|
|
|
|
UKismetMathLibrary_Add_FloatFloat_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_DateTimeTimespan
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime A (Parm)
|
|
// struct FTimespan B (Parm)
|
|
// struct FDateTime ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDateTime UKismetMathLibrary::Add_DateTimeTimespan(const struct FDateTime& A, const struct FTimespan& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_DateTimeTimespan");
|
|
|
|
UKismetMathLibrary_Add_DateTimeTimespan_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Add_ByteByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char B (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetMathLibrary::Add_ByteByte(unsigned char A, unsigned char B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Add_ByteByte");
|
|
|
|
UKismetMathLibrary_Add_ByteByte_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Acos
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Acos(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Acos");
|
|
|
|
UKismetMathLibrary_Acos_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Abs_Int
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetMathLibrary::Abs_Int(int A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Abs_Int");
|
|
|
|
UKismetMathLibrary_Abs_Int_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetMathLibrary.Abs
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float A (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetMathLibrary::Abs(float A)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetMathLibrary.Abs");
|
|
|
|
UKismetMathLibrary_Abs_Params params;
|
|
params.A = A;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.MarkBit
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetNodeHelperLibrary::MarkBit(int Index, int* Data)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.MarkBit");
|
|
|
|
UKismetNodeHelperLibrary_MarkBit_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Data != nullptr)
|
|
*Data = params.Data;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.HasUnmarkedBit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumBits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetNodeHelperLibrary::HasUnmarkedBit(int Data, int NumBits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.HasUnmarkedBit");
|
|
|
|
UKismetNodeHelperLibrary_HasUnmarkedBit_Params params;
|
|
params.Data = Data;
|
|
params.NumBits = NumBits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.HasMarkedBit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumBits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetNodeHelperLibrary::HasMarkedBit(int Data, int NumBits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.HasMarkedBit");
|
|
|
|
UKismetNodeHelperLibrary_HasMarkedBit_Params params;
|
|
params.Data = Data;
|
|
params.NumBits = NumBits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetValidValue
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UEnum* Enum (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char EnumeratorValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetNodeHelperLibrary::GetValidValue(class UEnum* Enum, unsigned char EnumeratorValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetValidValue");
|
|
|
|
UKismetNodeHelperLibrary_GetValidValue_Params params;
|
|
params.Enum = Enum;
|
|
params.EnumeratorValue = EnumeratorValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetUnmarkedBit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StartIdx (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumBits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bRandom (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetNodeHelperLibrary::GetUnmarkedBit(int Data, int StartIdx, int NumBits, bool bRandom)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetUnmarkedBit");
|
|
|
|
UKismetNodeHelperLibrary_GetUnmarkedBit_Params params;
|
|
params.Data = Data;
|
|
params.StartIdx = StartIdx;
|
|
params.NumBits = NumBits;
|
|
params.bRandom = bRandom;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetRandomUnmarkedBit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StartIdx (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumBits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetNodeHelperLibrary::GetRandomUnmarkedBit(int Data, int StartIdx, int NumBits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetRandomUnmarkedBit");
|
|
|
|
UKismetNodeHelperLibrary_GetRandomUnmarkedBit_Params params;
|
|
params.Data = Data;
|
|
params.StartIdx = StartIdx;
|
|
params.NumBits = NumBits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetFirstUnmarkedBit
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StartIdx (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumBits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetNodeHelperLibrary::GetFirstUnmarkedBit(int Data, int StartIdx, int NumBits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetFirstUnmarkedBit");
|
|
|
|
UKismetNodeHelperLibrary_GetFirstUnmarkedBit_Params params;
|
|
params.Data = Data;
|
|
params.StartIdx = StartIdx;
|
|
params.NumBits = NumBits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetEnumeratorValueFromIndex
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UEnum* Enum (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char EnumeratorIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetNodeHelperLibrary::GetEnumeratorValueFromIndex(class UEnum* Enum, unsigned char EnumeratorIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetEnumeratorValueFromIndex");
|
|
|
|
UKismetNodeHelperLibrary_GetEnumeratorValueFromIndex_Params params;
|
|
params.Enum = Enum;
|
|
params.EnumeratorIndex = EnumeratorIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetEnumeratorUserFriendlyName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UEnum* Enum (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char EnumeratorValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetNodeHelperLibrary::GetEnumeratorUserFriendlyName(class UEnum* Enum, unsigned char EnumeratorValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetEnumeratorUserFriendlyName");
|
|
|
|
UKismetNodeHelperLibrary_GetEnumeratorUserFriendlyName_Params params;
|
|
params.Enum = Enum;
|
|
params.EnumeratorValue = EnumeratorValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.GetEnumeratorName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UEnum* Enum (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char EnumeratorValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UKismetNodeHelperLibrary::GetEnumeratorName(class UEnum* Enum, unsigned char EnumeratorValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.GetEnumeratorName");
|
|
|
|
UKismetNodeHelperLibrary_GetEnumeratorName_Params params;
|
|
params.Enum = Enum;
|
|
params.EnumeratorValue = EnumeratorValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.ClearBit
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetNodeHelperLibrary::ClearBit(int Index, int* Data)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.ClearBit");
|
|
|
|
UKismetNodeHelperLibrary_ClearBit_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Data != nullptr)
|
|
*Data = params.Data;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.ClearAllBits
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetNodeHelperLibrary::ClearAllBits(int* Data)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.ClearAllBits");
|
|
|
|
UKismetNodeHelperLibrary_ClearAllBits_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Data != nullptr)
|
|
*Data = params.Data;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetNodeHelperLibrary.BitIsMarked
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Data (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetNodeHelperLibrary::BitIsMarked(int Data, int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetNodeHelperLibrary.BitIsMarked");
|
|
|
|
UKismetNodeHelperLibrary_BitIsMarked_Params params;
|
|
params.Data = Data;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.RenderTargetCreateStaticTexture2DEditorOnly
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTextureRenderTarget2D* RenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Name (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ETextureCompressionSettings> CompressionSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETextureMipGenSettings> MipSettings (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UTexture2D* UKismetRenderingLibrary::RenderTargetCreateStaticTexture2DEditorOnly(class UTextureRenderTarget2D* RenderTarget, const struct FString& Name, TEnumAsByte<ETextureCompressionSettings> CompressionSettings, TEnumAsByte<ETextureMipGenSettings> MipSettings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.RenderTargetCreateStaticTexture2DEditorOnly");
|
|
|
|
UKismetRenderingLibrary_RenderTargetCreateStaticTexture2DEditorOnly_Params params;
|
|
params.RenderTarget = RenderTarget;
|
|
params.Name = Name;
|
|
params.CompressionSettings = CompressionSettings;
|
|
params.MipSettings = MipSettings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.ReleaseRenderTarget2D
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTextureRenderTarget2D* TextureRenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetRenderingLibrary::ReleaseRenderTarget2D(class UTextureRenderTarget2D* TextureRenderTarget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.ReleaseRenderTarget2D");
|
|
|
|
UKismetRenderingLibrary_ReleaseRenderTarget2D_Params params;
|
|
params.TextureRenderTarget = TextureRenderTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.MakeSkinWeightInfo
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Bone0 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight0 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Bone1 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight1 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Bone2 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight2 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Bone3 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight3 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FSkelMeshSkinWeightInfo ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FSkelMeshSkinWeightInfo UKismetRenderingLibrary::MakeSkinWeightInfo(int Bone0, unsigned char Weight0, int Bone1, unsigned char Weight1, int Bone2, unsigned char Weight2, int Bone3, unsigned char Weight3)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.MakeSkinWeightInfo");
|
|
|
|
UKismetRenderingLibrary_MakeSkinWeightInfo_Params params;
|
|
params.Bone0 = Bone0;
|
|
params.Weight0 = Weight0;
|
|
params.Bone1 = Bone1;
|
|
params.Weight1 = Weight1;
|
|
params.Bone2 = Bone2;
|
|
params.Weight2 = Weight2;
|
|
params.Bone3 = Bone3;
|
|
params.Weight3 = Weight3;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.ExportTexture2D
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FilePath (Parm, ZeroConstructor)
|
|
// struct FString Filename (Parm, ZeroConstructor)
|
|
|
|
void UKismetRenderingLibrary::ExportTexture2D(class UObject* WorldContextObject, class UTexture2D* Texture, const struct FString& FilePath, const struct FString& Filename)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.ExportTexture2D");
|
|
|
|
UKismetRenderingLibrary_ExportTexture2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Texture = Texture;
|
|
params.FilePath = FilePath;
|
|
params.Filename = Filename;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.ExportRenderTarget
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureRenderTarget2D* TextureRenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FilePath (Parm, ZeroConstructor)
|
|
// struct FString Filename (Parm, ZeroConstructor)
|
|
|
|
void UKismetRenderingLibrary::ExportRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, const struct FString& FilePath, const struct FString& Filename)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.ExportRenderTarget");
|
|
|
|
UKismetRenderingLibrary_ExportRenderTarget_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TextureRenderTarget = TextureRenderTarget;
|
|
params.FilePath = FilePath;
|
|
params.Filename = Filename;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.EndDrawCanvasToRenderTarget
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDrawToRenderTargetContext Context (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetRenderingLibrary::EndDrawCanvasToRenderTarget(class UObject* WorldContextObject, const struct FDrawToRenderTargetContext& Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.EndDrawCanvasToRenderTarget");
|
|
|
|
UKismetRenderingLibrary_EndDrawCanvasToRenderTarget_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Context = Context;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.DrawMaterialToRenderTarget
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureRenderTarget2D* TextureRenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetRenderingLibrary::DrawMaterialToRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, class UMaterialInterface* Material)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.DrawMaterialToRenderTarget");
|
|
|
|
UKismetRenderingLibrary_DrawMaterialToRenderTarget_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TextureRenderTarget = TextureRenderTarget;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.CreateRenderTarget2D
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Width (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Height (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETextureRenderTargetFormat> Format (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureRenderTarget2D* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UTextureRenderTarget2D* UKismetRenderingLibrary::CreateRenderTarget2D(class UObject* WorldContextObject, int Width, int Height, TEnumAsByte<ETextureRenderTargetFormat> Format)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.CreateRenderTarget2D");
|
|
|
|
UKismetRenderingLibrary_CreateRenderTarget2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Width = Width;
|
|
params.Height = Height;
|
|
params.Format = Format;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.ConvertRenderTargetToTexture2DEditorOnly
|
|
// (Final, RequiredAPI, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureRenderTarget2D* RenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture2D* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetRenderingLibrary::ConvertRenderTargetToTexture2DEditorOnly(class UObject* WorldContextObject, class UTextureRenderTarget2D* RenderTarget, class UTexture2D* Texture)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.ConvertRenderTargetToTexture2DEditorOnly");
|
|
|
|
UKismetRenderingLibrary_ConvertRenderTargetToTexture2DEditorOnly_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.RenderTarget = RenderTarget;
|
|
params.Texture = Texture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.ClearRenderTarget2D
|
|
// (Final, RequiredAPI, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureRenderTarget2D* TextureRenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ClearColor (Parm, IsPlainOldData)
|
|
|
|
void UKismetRenderingLibrary::ClearRenderTarget2D(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, const struct FLinearColor& ClearColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.ClearRenderTarget2D");
|
|
|
|
UKismetRenderingLibrary_ClearRenderTarget2D_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TextureRenderTarget = TextureRenderTarget;
|
|
params.ClearColor = ClearColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.BreakSkinWeightInfo
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSkelMeshSkinWeightInfo InWeight (Parm, IsPlainOldData)
|
|
// int Bone0 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight0 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Bone1 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight1 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Bone2 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight2 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// int Bone3 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Weight3 (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetRenderingLibrary::BreakSkinWeightInfo(const struct FSkelMeshSkinWeightInfo& InWeight, int* Bone0, unsigned char* Weight0, int* Bone1, unsigned char* Weight1, int* Bone2, unsigned char* Weight2, int* Bone3, unsigned char* Weight3)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.BreakSkinWeightInfo");
|
|
|
|
UKismetRenderingLibrary_BreakSkinWeightInfo_Params params;
|
|
params.InWeight = InWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Bone0 != nullptr)
|
|
*Bone0 = params.Bone0;
|
|
if (Weight0 != nullptr)
|
|
*Weight0 = params.Weight0;
|
|
if (Bone1 != nullptr)
|
|
*Bone1 = params.Bone1;
|
|
if (Weight1 != nullptr)
|
|
*Weight1 = params.Weight1;
|
|
if (Bone2 != nullptr)
|
|
*Bone2 = params.Bone2;
|
|
if (Weight2 != nullptr)
|
|
*Weight2 = params.Weight2;
|
|
if (Bone3 != nullptr)
|
|
*Bone3 = params.Bone3;
|
|
if (Weight3 != nullptr)
|
|
*Weight3 = params.Weight3;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetRenderingLibrary.BeginDrawCanvasToRenderTarget
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureRenderTarget2D* TextureRenderTarget (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCanvas* Canvas (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D Size (Parm, OutParm, IsPlainOldData)
|
|
// struct FDrawToRenderTargetContext Context (Parm, OutParm)
|
|
|
|
void UKismetRenderingLibrary::BeginDrawCanvasToRenderTarget(class UObject* WorldContextObject, class UTextureRenderTarget2D* TextureRenderTarget, class UCanvas** Canvas, struct FVector2D* Size, struct FDrawToRenderTargetContext* Context)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetRenderingLibrary.BeginDrawCanvasToRenderTarget");
|
|
|
|
UKismetRenderingLibrary_BeginDrawCanvasToRenderTarget_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TextureRenderTarget = TextureRenderTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Canvas != nullptr)
|
|
*Canvas = params.Canvas;
|
|
if (Size != nullptr)
|
|
*Size = params.Size;
|
|
if (Context != nullptr)
|
|
*Context = params.Context;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.TrimTrailing
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::TrimTrailing(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.TrimTrailing");
|
|
|
|
UKismetStringLibrary_TrimTrailing_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Trim
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Trim(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Trim");
|
|
|
|
UKismetStringLibrary_Trim_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.ToUpper
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::ToUpper(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.ToUpper");
|
|
|
|
UKismetStringLibrary_ToUpper_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.ToLower
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::ToLower(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.ToLower");
|
|
|
|
UKismetStringLibrary_ToLower_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.TimeSecondsToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float InSeconds (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::TimeSecondsToString(float InSeconds)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.TimeSecondsToString");
|
|
|
|
UKismetStringLibrary_TimeSecondsToString_Params params;
|
|
params.InSeconds = InSeconds;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.StartsWith
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString InPrefix (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ESearchCase> SearchCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::StartsWith(const struct FString& SourceString, const struct FString& InPrefix, TEnumAsByte<ESearchCase> SearchCase)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.StartsWith");
|
|
|
|
UKismetStringLibrary_StartsWith_Params params;
|
|
params.SourceString = SourceString;
|
|
params.InPrefix = InPrefix;
|
|
params.SearchCase = SearchCase;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Split
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString InStr (Parm, ZeroConstructor)
|
|
// struct FString LeftS (Parm, OutParm, ZeroConstructor)
|
|
// struct FString RightS (Parm, OutParm, ZeroConstructor)
|
|
// TEnumAsByte<ESearchCase> SearchCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESearchDir> SearchDir (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::Split(const struct FString& SourceString, const struct FString& InStr, TEnumAsByte<ESearchCase> SearchCase, TEnumAsByte<ESearchDir> SearchDir, struct FString* LeftS, struct FString* RightS)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Split");
|
|
|
|
UKismetStringLibrary_Split_Params params;
|
|
params.SourceString = SourceString;
|
|
params.InStr = InStr;
|
|
params.SearchCase = SearchCase;
|
|
params.SearchDir = SearchDir;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LeftS != nullptr)
|
|
*LeftS = params.LeftS;
|
|
if (RightS != nullptr)
|
|
*RightS = params.RightS;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.RightPad
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int ChCount (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::RightPad(const struct FString& SourceString, int ChCount)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.RightPad");
|
|
|
|
UKismetStringLibrary_RightPad_Params params;
|
|
params.SourceString = SourceString;
|
|
params.ChCount = ChCount;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.RightChop
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int Count (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::RightChop(const struct FString& SourceString, int Count)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.RightChop");
|
|
|
|
UKismetStringLibrary_RightChop_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Count = Count;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Right
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int Count (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Right(const struct FString& SourceString, int Count)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Right");
|
|
|
|
UKismetStringLibrary_Right_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Count = Count;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Reverse
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Reverse(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Reverse");
|
|
|
|
UKismetStringLibrary_Reverse_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.ReplaceInline
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// struct FString SearchText (Parm, ZeroConstructor)
|
|
// struct FString ReplacementText (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ESearchCase> SearchCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetStringLibrary::ReplaceInline(const struct FString& SearchText, const struct FString& ReplacementText, TEnumAsByte<ESearchCase> SearchCase, struct FString* SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.ReplaceInline");
|
|
|
|
UKismetStringLibrary_ReplaceInline_Params params;
|
|
params.SearchText = SearchText;
|
|
params.ReplacementText = ReplacementText;
|
|
params.SearchCase = SearchCase;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (SourceString != nullptr)
|
|
*SourceString = params.SourceString;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Replace
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString From (Parm, ZeroConstructor)
|
|
// struct FString To (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ESearchCase> SearchCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Replace(const struct FString& SourceString, const struct FString& From, const struct FString& To, TEnumAsByte<ESearchCase> SearchCase)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Replace");
|
|
|
|
UKismetStringLibrary_Replace_Params params;
|
|
params.SourceString = SourceString;
|
|
params.From = From;
|
|
params.To = To;
|
|
params.SearchCase = SearchCase;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.ParseIntoArray
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString Delimiter (Parm, ZeroConstructor)
|
|
// bool CullEmptyStrings (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FString> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FString> UKismetStringLibrary::ParseIntoArray(const struct FString& SourceString, const struct FString& Delimiter, bool CullEmptyStrings)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.ParseIntoArray");
|
|
|
|
UKismetStringLibrary_ParseIntoArray_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Delimiter = Delimiter;
|
|
params.CullEmptyStrings = CullEmptyStrings;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.NotEqual_StrStr
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString A (Parm, ZeroConstructor)
|
|
// struct FString B (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::NotEqual_StrStr(const struct FString& A, const struct FString& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.NotEqual_StrStr");
|
|
|
|
UKismetStringLibrary_NotEqual_StrStr_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.NotEqual_StriStri
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString A (Parm, ZeroConstructor)
|
|
// struct FString B (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::NotEqual_StriStri(const struct FString& A, const struct FString& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.NotEqual_StriStri");
|
|
|
|
UKismetStringLibrary_NotEqual_StriStri_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Mid
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int Start (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Count (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Mid(const struct FString& SourceString, int Start, int Count)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Mid");
|
|
|
|
UKismetStringLibrary_Mid_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Start = Start;
|
|
params.Count = Count;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.MatchesWildcard
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString Wildcard (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ESearchCase> SearchCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::MatchesWildcard(const struct FString& SourceString, const struct FString& Wildcard, TEnumAsByte<ESearchCase> SearchCase)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.MatchesWildcard");
|
|
|
|
UKismetStringLibrary_MatchesWildcard_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Wildcard = Wildcard;
|
|
params.SearchCase = SearchCase;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Len
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString S (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetStringLibrary::Len(const struct FString& S)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Len");
|
|
|
|
UKismetStringLibrary_Len_Params params;
|
|
params.S = S;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.LeftPad
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int ChCount (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::LeftPad(const struct FString& SourceString, int ChCount)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.LeftPad");
|
|
|
|
UKismetStringLibrary_LeftPad_Params params;
|
|
params.SourceString = SourceString;
|
|
params.ChCount = ChCount;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.LeftChop
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int Count (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::LeftChop(const struct FString& SourceString, int Count)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.LeftChop");
|
|
|
|
UKismetStringLibrary_LeftChop_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Count = Count;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Left
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int Count (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Left(const struct FString& SourceString, int Count)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Left");
|
|
|
|
UKismetStringLibrary_Left_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Count = Count;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.JoinStringArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<struct FString> SourceArray (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// struct FString Separator (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::JoinStringArray(TArray<struct FString> SourceArray, const struct FString& Separator)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.JoinStringArray");
|
|
|
|
UKismetStringLibrary_JoinStringArray_Params params;
|
|
params.SourceArray = SourceArray;
|
|
params.Separator = Separator;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.IsNumeric
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::IsNumeric(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.IsNumeric");
|
|
|
|
UKismetStringLibrary_IsNumeric_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.GetSubstring
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int StartIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Length (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::GetSubstring(const struct FString& SourceString, int StartIndex, int Length)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.GetSubstring");
|
|
|
|
UKismetStringLibrary_GetSubstring_Params params;
|
|
params.SourceString = SourceString;
|
|
params.StartIndex = StartIndex;
|
|
params.Length = Length;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.GetCharacterAsNumber
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetStringLibrary::GetCharacterAsNumber(const struct FString& SourceString, int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.GetCharacterAsNumber");
|
|
|
|
UKismetStringLibrary_GetCharacterAsNumber_Params params;
|
|
params.SourceString = SourceString;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.GetCharacterArrayFromString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// TArray<struct FString> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FString> UKismetStringLibrary::GetCharacterArrayFromString(const struct FString& SourceString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.GetCharacterArrayFromString");
|
|
|
|
UKismetStringLibrary_GetCharacterArrayFromString_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.FindSubstring
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SearchIn (Parm, ZeroConstructor)
|
|
// struct FString Substring (Parm, ZeroConstructor)
|
|
// bool bUseCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSearchFromEnd (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int StartPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetStringLibrary::FindSubstring(const struct FString& SearchIn, const struct FString& Substring, bool bUseCase, bool bSearchFromEnd, int StartPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.FindSubstring");
|
|
|
|
UKismetStringLibrary_FindSubstring_Params params;
|
|
params.SearchIn = SearchIn;
|
|
params.Substring = Substring;
|
|
params.bUseCase = bUseCase;
|
|
params.bSearchFromEnd = bSearchFromEnd;
|
|
params.StartPosition = StartPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.EqualEqual_StrStr
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString A (Parm, ZeroConstructor)
|
|
// struct FString B (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::EqualEqual_StrStr(const struct FString& A, const struct FString& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.EqualEqual_StrStr");
|
|
|
|
UKismetStringLibrary_EqualEqual_StrStr_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.EqualEqual_StriStri
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString A (Parm, ZeroConstructor)
|
|
// struct FString B (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::EqualEqual_StriStri(const struct FString& A, const struct FString& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.EqualEqual_StriStri");
|
|
|
|
UKismetStringLibrary_EqualEqual_StriStri_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.EndsWith
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// struct FString InSuffix (Parm, ZeroConstructor)
|
|
// TEnumAsByte<ESearchCase> SearchCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::EndsWith(const struct FString& SourceString, const struct FString& InSuffix, TEnumAsByte<ESearchCase> SearchCase)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.EndsWith");
|
|
|
|
UKismetStringLibrary_EndsWith_Params params;
|
|
params.SourceString = SourceString;
|
|
params.InSuffix = InSuffix;
|
|
params.SearchCase = SearchCase;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.CullArray
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SourceString (Parm, ZeroConstructor)
|
|
// TArray<struct FString> inArray (Parm, OutParm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetStringLibrary::CullArray(const struct FString& SourceString, TArray<struct FString>* inArray)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.CullArray");
|
|
|
|
UKismetStringLibrary_CullArray_Params params;
|
|
params.SourceString = SourceString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (inArray != nullptr)
|
|
*inArray = params.inArray;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_VectorToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVec (Parm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_VectorToString(const struct FVector& InVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_VectorToString");
|
|
|
|
UKismetStringLibrary_Conv_VectorToString_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_Vector2dToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D InVec (Parm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_Vector2dToString(const struct FVector2D& InVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_Vector2dToString");
|
|
|
|
UKismetStringLibrary_Conv_Vector2dToString_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_TransformToString
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform InTrans (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_TransformToString(const struct FTransform& InTrans)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_TransformToString");
|
|
|
|
UKismetStringLibrary_Conv_TransformToString_Params params;
|
|
params.InTrans = InTrans;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToVector2D
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FVector2D OutConvertedVector2D (Parm, OutParm, IsPlainOldData)
|
|
// bool OutIsValid (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetStringLibrary::Conv_StringToVector2D(const struct FString& inString, struct FVector2D* OutConvertedVector2D, bool* OutIsValid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToVector2D");
|
|
|
|
UKismetStringLibrary_Conv_StringToVector2D_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutConvertedVector2D != nullptr)
|
|
*OutConvertedVector2D = params.OutConvertedVector2D;
|
|
if (OutIsValid != nullptr)
|
|
*OutIsValid = params.OutIsValid;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToVector
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FVector OutConvertedVector (Parm, OutParm, IsPlainOldData)
|
|
// bool OutIsValid (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetStringLibrary::Conv_StringToVector(const struct FString& inString, struct FVector* OutConvertedVector, bool* OutIsValid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToVector");
|
|
|
|
UKismetStringLibrary_Conv_StringToVector_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutConvertedVector != nullptr)
|
|
*OutConvertedVector = params.OutConvertedVector;
|
|
if (OutIsValid != nullptr)
|
|
*OutIsValid = params.OutIsValid;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToRotator
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FRotator OutConvertedRotator (Parm, OutParm, IsPlainOldData)
|
|
// bool OutIsValid (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetStringLibrary::Conv_StringToRotator(const struct FString& inString, struct FRotator* OutConvertedRotator, bool* OutIsValid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToRotator");
|
|
|
|
UKismetStringLibrary_Conv_StringToRotator_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutConvertedRotator != nullptr)
|
|
*OutConvertedRotator = params.OutConvertedRotator;
|
|
if (OutIsValid != nullptr)
|
|
*OutIsValid = params.OutIsValid;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UKismetStringLibrary::Conv_StringToName(const struct FString& inString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToName");
|
|
|
|
UKismetStringLibrary_Conv_StringToName_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetStringLibrary::Conv_StringToInt(const struct FString& inString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToInt");
|
|
|
|
UKismetStringLibrary_Conv_StringToInt_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetStringLibrary::Conv_StringToFloat(const struct FString& inString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToFloat");
|
|
|
|
UKismetStringLibrary_Conv_StringToFloat_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_StringToColor
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FLinearColor OutConvertedColor (Parm, OutParm, IsPlainOldData)
|
|
// bool OutIsValid (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetStringLibrary::Conv_StringToColor(const struct FString& inString, struct FLinearColor* OutConvertedColor, bool* OutIsValid)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_StringToColor");
|
|
|
|
UKismetStringLibrary_Conv_StringToColor_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutConvertedColor != nullptr)
|
|
*OutConvertedColor = params.OutConvertedColor;
|
|
if (OutIsValid != nullptr)
|
|
*OutIsValid = params.OutIsValid;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_RotatorToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_RotatorToString(const struct FRotator& InRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_RotatorToString");
|
|
|
|
UKismetStringLibrary_Conv_RotatorToString_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_ObjectToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* InObj (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_ObjectToString(class UObject* InObj)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_ObjectToString");
|
|
|
|
UKismetStringLibrary_Conv_ObjectToString_Params params;
|
|
params.InObj = InObj;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_NameToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_NameToString(const struct FName& InName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_NameToString");
|
|
|
|
UKismetStringLibrary_Conv_NameToString_Params params;
|
|
params.InName = InName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_IntVectorToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FIntVector InIntVec (Parm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_IntVectorToString(const struct FIntVector& InIntVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_IntVectorToString");
|
|
|
|
UKismetStringLibrary_Conv_IntVectorToString_Params params;
|
|
params.InIntVec = InIntVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_IntToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_IntToString(int inInt)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_IntToString");
|
|
|
|
UKismetStringLibrary_Conv_IntToString_Params params;
|
|
params.inInt = inInt;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_FloatToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float InFloat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_FloatToString(float InFloat)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_FloatToString");
|
|
|
|
UKismetStringLibrary_Conv_FloatToString_Params params;
|
|
params.InFloat = InFloat;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_ColorToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor InColor (Parm, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_ColorToString(const struct FLinearColor& InColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_ColorToString");
|
|
|
|
UKismetStringLibrary_Conv_ColorToString_Params params;
|
|
params.InColor = InColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_ByteToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char InByte (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_ByteToString(unsigned char InByte)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_ByteToString");
|
|
|
|
UKismetStringLibrary_Conv_ByteToString_Params params;
|
|
params.InByte = InByte;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Conv_BoolToString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Conv_BoolToString(bool InBool)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Conv_BoolToString");
|
|
|
|
UKismetStringLibrary_Conv_BoolToString_Params params;
|
|
params.InBool = InBool;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Contains
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString SearchIn (Parm, ZeroConstructor)
|
|
// struct FString Substring (Parm, ZeroConstructor)
|
|
// bool bUseCase (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSearchFromEnd (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringLibrary::Contains(const struct FString& SearchIn, const struct FString& Substring, bool bUseCase, bool bSearchFromEnd)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Contains");
|
|
|
|
UKismetStringLibrary_Contains_Params params;
|
|
params.SearchIn = SearchIn;
|
|
params.Substring = Substring;
|
|
params.bUseCase = bUseCase;
|
|
params.bSearchFromEnd = bSearchFromEnd;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.Concat_StrStr
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString A (Parm, ZeroConstructor)
|
|
// struct FString B (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::Concat_StrStr(const struct FString& A, const struct FString& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.Concat_StrStr");
|
|
|
|
UKismetStringLibrary_Concat_StrStr_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Vector2d
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// struct FVector2D InVector2D (Parm, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Vector2d(const struct FString& AppendTo, const struct FString& Prefix, const struct FVector2D& InVector2D, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Vector2d");
|
|
|
|
UKismetStringLibrary_BuildString_Vector2d_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InVector2D = InVector2D;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Vector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// struct FVector InVector (Parm, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Vector(const struct FString& AppendTo, const struct FString& Prefix, const struct FVector& InVector, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Vector");
|
|
|
|
UKismetStringLibrary_BuildString_Vector_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InVector = InVector;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Rotator
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Rotator(const struct FString& AppendTo, const struct FString& Prefix, const struct FRotator& InRot, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Rotator");
|
|
|
|
UKismetStringLibrary_BuildString_Rotator_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InRot = InRot;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Object
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// class UObject* InObj (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Object(const struct FString& AppendTo, const struct FString& Prefix, class UObject* InObj, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Object");
|
|
|
|
UKismetStringLibrary_BuildString_Object_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InObj = InObj;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Name
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Name(const struct FString& AppendTo, const struct FString& Prefix, const struct FName& InName, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Name");
|
|
|
|
UKismetStringLibrary_BuildString_Name_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InName = InName;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_IntVector
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// struct FIntVector InIntVector (Parm, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_IntVector(const struct FString& AppendTo, const struct FString& Prefix, const struct FIntVector& InIntVector, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_IntVector");
|
|
|
|
UKismetStringLibrary_BuildString_IntVector_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InIntVector = InIntVector;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Int
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// int inInt (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Int(const struct FString& AppendTo, const struct FString& Prefix, int inInt, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Int");
|
|
|
|
UKismetStringLibrary_BuildString_Int_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.inInt = inInt;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Float
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// float InFloat (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Float(const struct FString& AppendTo, const struct FString& Prefix, float InFloat, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Float");
|
|
|
|
UKismetStringLibrary_BuildString_Float_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InFloat = InFloat;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Color
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// struct FLinearColor InColor (Parm, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Color(const struct FString& AppendTo, const struct FString& Prefix, const struct FLinearColor& InColor, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Color");
|
|
|
|
UKismetStringLibrary_BuildString_Color_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InColor = InColor;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringLibrary.BuildString_Bool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString AppendTo (Parm, ZeroConstructor)
|
|
// struct FString Prefix (Parm, ZeroConstructor)
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Suffix (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringLibrary::BuildString_Bool(const struct FString& AppendTo, const struct FString& Prefix, bool InBool, const struct FString& Suffix)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringLibrary.BuildString_Bool");
|
|
|
|
UKismetStringLibrary_BuildString_Bool_Params params;
|
|
params.AppendTo = AppendTo;
|
|
params.Prefix = Prefix;
|
|
params.InBool = InBool;
|
|
params.Suffix = Suffix;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.IsRegisteredTableId
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringTableLibrary::IsRegisteredTableId(const struct FName& TableId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.IsRegisteredTableId");
|
|
|
|
UKismetStringTableLibrary_IsRegisteredTableId_Params params;
|
|
params.TableId = TableId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.IsRegisteredTableEntry
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetStringTableLibrary::IsRegisteredTableEntry(const struct FName& TableId, const struct FString& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.IsRegisteredTableEntry");
|
|
|
|
UKismetStringTableLibrary_IsRegisteredTableEntry_Params params;
|
|
params.TableId = TableId;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.GetTableNamespace
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringTableLibrary::GetTableNamespace(const struct FName& TableId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.GetTableNamespace");
|
|
|
|
UKismetStringTableLibrary_GetTableNamespace_Params params;
|
|
params.TableId = TableId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.GetTableEntrySourceString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringTableLibrary::GetTableEntrySourceString(const struct FName& TableId, const struct FString& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.GetTableEntrySourceString");
|
|
|
|
UKismetStringTableLibrary_GetTableEntrySourceString_Params params;
|
|
params.TableId = TableId;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.GetTableEntryMetaData
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// struct FName MetaDataId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetStringTableLibrary::GetTableEntryMetaData(const struct FName& TableId, const struct FString& Key, const struct FName& MetaDataId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.GetTableEntryMetaData");
|
|
|
|
UKismetStringTableLibrary_GetTableEntryMetaData_Params params;
|
|
params.TableId = TableId;
|
|
params.Key = Key;
|
|
params.MetaDataId = MetaDataId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.GetRegisteredStringTables
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TArray<struct FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FName> UKismetStringTableLibrary::GetRegisteredStringTables()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.GetRegisteredStringTables");
|
|
|
|
UKismetStringTableLibrary_GetRegisteredStringTables_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.GetMetaDataIdsFromStringTableEntry
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// TArray<struct FName> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FName> UKismetStringTableLibrary::GetMetaDataIdsFromStringTableEntry(const struct FName& TableId, const struct FString& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.GetMetaDataIdsFromStringTableEntry");
|
|
|
|
UKismetStringTableLibrary_GetMetaDataIdsFromStringTableEntry_Params params;
|
|
params.TableId = TableId;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetStringTableLibrary.GetKeysFromStringTable
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FString> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FString> UKismetStringTableLibrary::GetKeysFromStringTable(const struct FName& TableId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetStringTableLibrary.GetKeysFromStringTable");
|
|
|
|
UKismetStringTableLibrary_GetKeysFromStringTable_Params params;
|
|
params.TableId = TableId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.UnregisterForRemoteNotifications
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::UnregisterForRemoteNotifications()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.UnregisterForRemoteNotifications");
|
|
|
|
UKismetSystemLibrary_UnregisterForRemoteNotifications_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.UnloadPrimaryAssetList
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FPrimaryAssetId> PrimaryAssetIdList (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UKismetSystemLibrary::UnloadPrimaryAssetList(TArray<struct FPrimaryAssetId> PrimaryAssetIdList)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.UnloadPrimaryAssetList");
|
|
|
|
UKismetSystemLibrary_UnloadPrimaryAssetList_Params params;
|
|
params.PrimaryAssetIdList = PrimaryAssetIdList;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.UnloadPrimaryAsset
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
|
|
void UKismetSystemLibrary::UnloadPrimaryAsset(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.UnloadPrimaryAsset");
|
|
|
|
UKismetSystemLibrary_UnloadPrimaryAsset_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.StackTrace
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::StackTrace()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.StackTrace");
|
|
|
|
UKismetSystemLibrary_StackTrace_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereTraceSingleForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereTraceSingleForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereTraceSingleForObjects");
|
|
|
|
UKismetSystemLibrary_SphereTraceSingleForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereTraceSingleByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereTraceSingleByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereTraceSingleByProfile");
|
|
|
|
UKismetSystemLibrary_SphereTraceSingleByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereTraceSingle
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereTraceSingle(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereTraceSingle");
|
|
|
|
UKismetSystemLibrary_SphereTraceSingle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereTraceMultiForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereTraceMultiForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereTraceMultiForObjects");
|
|
|
|
UKismetSystemLibrary_SphereTraceMultiForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereTraceMultiByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereTraceMultiByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereTraceMultiByProfile");
|
|
|
|
UKismetSystemLibrary_SphereTraceMultiByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereTraceMulti
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereTraceMulti(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereTraceMulti");
|
|
|
|
UKismetSystemLibrary_SphereTraceMulti_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereOverlapComponents
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector SpherePos (ConstParm, Parm, IsPlainOldData)
|
|
// float SphereRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ComponentClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class UPrimitiveComponent*> OutComponents (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereOverlapComponents(class UObject* WorldContextObject, const struct FVector& SpherePos, float SphereRadius, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ComponentClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereOverlapComponents");
|
|
|
|
UKismetSystemLibrary_SphereOverlapComponents_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.SpherePos = SpherePos;
|
|
params.SphereRadius = SphereRadius;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ComponentClassFilter = ComponentClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutComponents != nullptr)
|
|
*OutComponents = params.OutComponents;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SphereOverlapActors
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector SpherePos (ConstParm, Parm, IsPlainOldData)
|
|
// float SphereRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ActorClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::SphereOverlapActors(class UObject* WorldContextObject, const struct FVector& SpherePos, float SphereRadius, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ActorClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SphereOverlapActors");
|
|
|
|
UKismetSystemLibrary_SphereOverlapActors_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.SpherePos = SpherePos;
|
|
params.SphereRadius = SphereRadius;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ActorClassFilter = ActorClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ShowPlatformSpecificLeaderboardScreen
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString CategoryName (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::ShowPlatformSpecificLeaderboardScreen(const struct FString& CategoryName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ShowPlatformSpecificLeaderboardScreen");
|
|
|
|
UKismetSystemLibrary_ShowPlatformSpecificLeaderboardScreen_Params params;
|
|
params.CategoryName = CategoryName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ShowPlatformSpecificAchievementsScreen
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class APlayerController* SpecificPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::ShowPlatformSpecificAchievementsScreen(class APlayerController* SpecificPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ShowPlatformSpecificAchievementsScreen");
|
|
|
|
UKismetSystemLibrary_ShowPlatformSpecificAchievementsScreen_Params params;
|
|
params.SpecificPlayer = SpecificPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ShowInterstitialAd
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::ShowInterstitialAd()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ShowInterstitialAd");
|
|
|
|
UKismetSystemLibrary_ShowInterstitialAd_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ShowAdBanner
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int AdIdIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShowOnBottomOfScreen (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::ShowAdBanner(int AdIdIndex, bool bShowOnBottomOfScreen)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ShowAdBanner");
|
|
|
|
UKismetSystemLibrary_ShowAdBanner_Params params;
|
|
params.AdIdIndex = AdIdIndex;
|
|
params.bShowOnBottomOfScreen = bShowOnBottomOfScreen;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetWindowTitle
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText Title (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetSystemLibrary::SetWindowTitle(const struct FText& Title)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetWindowTitle");
|
|
|
|
UKismetSystemLibrary_SetWindowTitle_Params params;
|
|
params.Title = Title;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetVolumeButtonsHandledBySystem
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetVolumeButtonsHandledBySystem(bool bEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetVolumeButtonsHandledBySystem");
|
|
|
|
UKismetSystemLibrary_SetVolumeButtonsHandledBySystem_Params params;
|
|
params.bEnabled = bEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetVectorPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Value (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetVectorPropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FVector& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetVectorPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetVectorPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetUserActivity
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FUserActivity UserActivity (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetSystemLibrary::SetUserActivity(const struct FUserActivity& UserActivity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetUserActivity");
|
|
|
|
UKismetSystemLibrary_SetUserActivity_Params params;
|
|
params.UserActivity = UserActivity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetTransformPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform Value (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetTransformPropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FTransform& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetTransformPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetTransformPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetTextPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText Value (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetSystemLibrary::SetTextPropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FText& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetTextPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetTextPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetSuppressViewportTransitionMessage
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bState (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetSuppressViewportTransitionMessage(class UObject* WorldContextObject, bool bState)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetSuppressViewportTransitionMessage");
|
|
|
|
UKismetSystemLibrary_SetSuppressViewportTransitionMessage_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.bState = bState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetStructurePropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FGenericStruct Value (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetStructurePropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FGenericStruct& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetStructurePropertyByName");
|
|
|
|
UKismetSystemLibrary_SetStructurePropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetStringPropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Value (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::SetStringPropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FString& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetStringPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetStringPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetSoftObjectPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetSoftObjectPropertyByName(class UObject* Object, const struct FName& PropertyName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetSoftObjectPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetSoftObjectPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetSoftClassPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetSoftClassPropertyByName(class UObject* Object, const struct FName& PropertyName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetSoftClassPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetSoftClassPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetRotatorPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator Value (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetRotatorPropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FRotator& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetRotatorPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetRotatorPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetObjectPropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UObject* Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetObjectPropertyByName(class UObject* Object, const struct FName& PropertyName, class UObject* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetObjectPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetObjectPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetNamePropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName Value (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetNamePropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FName& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetNamePropertyByName");
|
|
|
|
UKismetSystemLibrary_SetNamePropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetLinearColorPropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Value (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetLinearColorPropertyByName(class UObject* Object, const struct FName& PropertyName, const struct FLinearColor& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetLinearColorPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetLinearColorPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetIntPropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetIntPropertyByName(class UObject* Object, const struct FName& PropertyName, int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetIntPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetIntPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetInterfacePropertyByName
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TScriptInterface<class UInterface> Value (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetInterfacePropertyByName(class UObject* Object, const struct FName& PropertyName, const TScriptInterface<class UInterface>& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetInterfacePropertyByName");
|
|
|
|
UKismetSystemLibrary_SetInterfacePropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetFloatPropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetFloatPropertyByName(class UObject* Object, const struct FName& PropertyName, float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetFloatPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetFloatPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetCollisionProfileNameProperty
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FCollisionProfileName Value (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetSystemLibrary::SetCollisionProfileNameProperty(class UObject* Object, const struct FName& PropertyName, const struct FCollisionProfileName& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetCollisionProfileNameProperty");
|
|
|
|
UKismetSystemLibrary_SetCollisionProfileNameProperty_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetClassPropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetClassPropertyByName(class UObject* Object, const struct FName& PropertyName, class UClass* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetClassPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetClassPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetBytePropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetBytePropertyByName(class UObject* Object, const struct FName& PropertyName, unsigned char Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetBytePropertyByName");
|
|
|
|
UKismetSystemLibrary_SetBytePropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.SetBoolPropertyByName
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName PropertyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::SetBoolPropertyByName(class UObject* Object, const struct FName& PropertyName, bool Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.SetBoolPropertyByName");
|
|
|
|
UKismetSystemLibrary_SetBoolPropertyByName_Params params;
|
|
params.Object = Object;
|
|
params.PropertyName = PropertyName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.RetriggerableDelay
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UKismetSystemLibrary::RetriggerableDelay(class UObject* WorldContextObject, float Duration, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.RetriggerableDelay");
|
|
|
|
UKismetSystemLibrary_RetriggerableDelay_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Duration = Duration;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ResetGamepadAssignmentToController
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int ControllerId (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::ResetGamepadAssignmentToController(int ControllerId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ResetGamepadAssignmentToController");
|
|
|
|
UKismetSystemLibrary_ResetGamepadAssignmentToController_Params params;
|
|
params.ControllerId = ControllerId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ResetGamepadAssignments
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::ResetGamepadAssignments()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ResetGamepadAssignments");
|
|
|
|
UKismetSystemLibrary_ResetGamepadAssignments_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.RegisterForRemoteNotifications
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::RegisterForRemoteNotifications()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.RegisterForRemoteNotifications");
|
|
|
|
UKismetSystemLibrary_RegisterForRemoteNotifications_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.QuitGame
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class APlayerController* SpecificPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EQuitPreference> QuitPreference (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::QuitGame(class UObject* WorldContextObject, class APlayerController* SpecificPlayer, TEnumAsByte<EQuitPreference> QuitPreference)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.QuitGame");
|
|
|
|
UKismetSystemLibrary_QuitGame_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.SpecificPlayer = SpecificPlayer;
|
|
params.QuitPreference = QuitPreference;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.PrintWarning
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::PrintWarning(const struct FString& inString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.PrintWarning");
|
|
|
|
UKismetSystemLibrary_PrintWarning_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.PrintText
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText InText (ConstParm, Parm)
|
|
// bool bPrintToScreen (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPrintToLog (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TextColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::PrintText(class UObject* WorldContextObject, const struct FText& InText, bool bPrintToScreen, bool bPrintToLog, const struct FLinearColor& TextColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.PrintText");
|
|
|
|
UKismetSystemLibrary_PrintText_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.InText = InText;
|
|
params.bPrintToScreen = bPrintToScreen;
|
|
params.bPrintToLog = bPrintToLog;
|
|
params.TextColor = TextColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.PrintString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// bool bPrintToScreen (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bPrintToLog (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TextColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::PrintString(class UObject* WorldContextObject, const struct FString& inString, bool bPrintToScreen, bool bPrintToLog, const struct FLinearColor& TextColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.PrintString");
|
|
|
|
UKismetSystemLibrary_PrintString_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.inString = inString;
|
|
params.bPrintToScreen = bPrintToScreen;
|
|
params.bPrintToLog = bPrintToLog;
|
|
params.TextColor = TextColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.KismetSystemLibrary.OnAssetLoaded__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// class UObject* Loaded (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::OnAssetLoaded__DelegateSignature(class UObject* Loaded)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.KismetSystemLibrary.OnAssetLoaded__DelegateSignature");
|
|
|
|
UKismetSystemLibrary_OnAssetLoaded__DelegateSignature_Params params;
|
|
params.Loaded = Loaded;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.KismetSystemLibrary.OnAssetClassLoaded__DelegateSignature
|
|
// (Public, Delegate)
|
|
// Parameters:
|
|
// class UClass* Loaded (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::OnAssetClassLoaded__DelegateSignature(class UClass* Loaded)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.KismetSystemLibrary.OnAssetClassLoaded__DelegateSignature");
|
|
|
|
UKismetSystemLibrary_OnAssetClassLoaded__DelegateSignature_Params params;
|
|
params.Loaded = Loaded;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.NotEqual_SoftObjectReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::NotEqual_SoftObjectReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.NotEqual_SoftObjectReference");
|
|
|
|
UKismetSystemLibrary_NotEqual_SoftObjectReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.NotEqual_SoftClassReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::NotEqual_SoftClassReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.NotEqual_SoftClassReference");
|
|
|
|
UKismetSystemLibrary_NotEqual_SoftClassReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.NotEqual_PrimaryAssetType
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetType A (Parm)
|
|
// struct FPrimaryAssetType B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::NotEqual_PrimaryAssetType(const struct FPrimaryAssetType& A, const struct FPrimaryAssetType& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.NotEqual_PrimaryAssetType");
|
|
|
|
UKismetSystemLibrary_NotEqual_PrimaryAssetType_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.NotEqual_PrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId A (Parm)
|
|
// struct FPrimaryAssetId B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::NotEqual_PrimaryAssetId(const struct FPrimaryAssetId& A, const struct FPrimaryAssetId& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.NotEqual_PrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_NotEqual_PrimaryAssetId_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MoveComponentTo
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class USceneComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FVector TargetRelativeLocation (Parm, IsPlainOldData)
|
|
// struct FRotator TargetRelativeRotation (Parm, IsPlainOldData)
|
|
// bool bEaseOut (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEaseIn (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float OverTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bForceShortestRotationPath (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EMoveComponentAction> MoveAction (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UKismetSystemLibrary::MoveComponentTo(class USceneComponent* Component, const struct FVector& TargetRelativeLocation, const struct FRotator& TargetRelativeRotation, bool bEaseOut, bool bEaseIn, float OverTime, bool bForceShortestRotationPath, TEnumAsByte<EMoveComponentAction> MoveAction, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MoveComponentTo");
|
|
|
|
UKismetSystemLibrary_MoveComponentTo_Params params;
|
|
params.Component = Component;
|
|
params.TargetRelativeLocation = TargetRelativeLocation;
|
|
params.TargetRelativeRotation = TargetRelativeRotation;
|
|
params.bEaseOut = bEaseOut;
|
|
params.bEaseIn = bEaseIn;
|
|
params.OverTime = OverTime;
|
|
params.bForceShortestRotationPath = bForceShortestRotationPath;
|
|
params.MoveAction = MoveAction;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeSoftObjectPath
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString PathString (Parm, ZeroConstructor)
|
|
// struct FSoftObjectPath ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FSoftObjectPath UKismetSystemLibrary::MakeSoftObjectPath(const struct FString& PathString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeSoftObjectPath");
|
|
|
|
UKismetSystemLibrary_MakeSoftObjectPath_Params params;
|
|
params.PathString = PathString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText Value (Parm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetSystemLibrary::MakeLiteralText(const struct FText& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralText");
|
|
|
|
UKismetSystemLibrary_MakeLiteralText_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralString
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString Value (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::MakeLiteralString(const struct FString& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralString");
|
|
|
|
UKismetSystemLibrary_MakeLiteralString_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName UKismetSystemLibrary::MakeLiteralName(const struct FName& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralName");
|
|
|
|
UKismetSystemLibrary_MakeLiteralName_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralInt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetSystemLibrary::MakeLiteralInt(int Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralInt");
|
|
|
|
UKismetSystemLibrary_MakeLiteralInt_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralFloat
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::MakeLiteralFloat(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralFloat");
|
|
|
|
UKismetSystemLibrary_MakeLiteralFloat_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralByte
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// unsigned char ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
unsigned char UKismetSystemLibrary::MakeLiteralByte(unsigned char Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralByte");
|
|
|
|
UKismetSystemLibrary_MakeLiteralByte_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.MakeLiteralBool
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::MakeLiteralBool(bool Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.MakeLiteralBool");
|
|
|
|
UKismetSystemLibrary_MakeLiteralBool_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LoadInterstitialAd
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int AdIdIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::LoadInterstitialAd(int AdIdIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LoadInterstitialAd");
|
|
|
|
UKismetSystemLibrary_LoadInterstitialAd_Params params;
|
|
params.AdIdIndex = AdIdIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LoadAssetClass
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FScriptDelegate OnLoaded (Parm, ZeroConstructor)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UKismetSystemLibrary::LoadAssetClass(class UObject* WorldContextObject, const struct FScriptDelegate& OnLoaded, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LoadAssetClass");
|
|
|
|
UKismetSystemLibrary_LoadAssetClass_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.OnLoaded = OnLoaded;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LoadAsset
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FScriptDelegate OnLoaded (Parm, ZeroConstructor)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UKismetSystemLibrary::LoadAsset(class UObject* WorldContextObject, const struct FScriptDelegate& OnLoaded, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LoadAsset");
|
|
|
|
UKismetSystemLibrary_LoadAsset_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.OnLoaded = OnLoaded;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LineTraceSingleForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::LineTraceSingleForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LineTraceSingleForObjects");
|
|
|
|
UKismetSystemLibrary_LineTraceSingleForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LineTraceSingleByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::LineTraceSingleByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LineTraceSingleByProfile");
|
|
|
|
UKismetSystemLibrary_LineTraceSingleByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LineTraceSingle
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::LineTraceSingle(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LineTraceSingle");
|
|
|
|
UKismetSystemLibrary_LineTraceSingle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LineTraceMultiForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::LineTraceMultiForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LineTraceMultiForObjects");
|
|
|
|
UKismetSystemLibrary_LineTraceMultiForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LineTraceMultiByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::LineTraceMultiByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LineTraceMultiByProfile");
|
|
|
|
UKismetSystemLibrary_LineTraceMultiByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LineTraceMulti
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::LineTraceMulti(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LineTraceMulti");
|
|
|
|
UKismetSystemLibrary_LineTraceMulti_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.LaunchURL
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::LaunchURL(const struct FString& URL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.LaunchURL");
|
|
|
|
UKismetSystemLibrary_LaunchURL_Params params;
|
|
params.URL = URL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_UnPauseTimerHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
|
|
void UKismetSystemLibrary::K2_UnPauseTimerHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_UnPauseTimerHandle");
|
|
|
|
UKismetSystemLibrary_K2_UnPauseTimerHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_UnPauseTimerDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::K2_UnPauseTimerDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_UnPauseTimerDelegate");
|
|
|
|
UKismetSystemLibrary_K2_UnPauseTimerDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_UnPauseTimer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::K2_UnPauseTimer(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_UnPauseTimer");
|
|
|
|
UKismetSystemLibrary_K2_UnPauseTimer_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_TimerExistsHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_TimerExistsHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_TimerExistsHandle");
|
|
|
|
UKismetSystemLibrary_K2_TimerExistsHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_TimerExistsDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_TimerExistsDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_TimerExistsDelegate");
|
|
|
|
UKismetSystemLibrary_K2_TimerExistsDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_TimerExists
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_TimerExists(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_TimerExists");
|
|
|
|
UKismetSystemLibrary_K2_TimerExists_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_SetTimerDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimerHandle UKismetSystemLibrary::K2_SetTimerDelegate(const struct FScriptDelegate& Delegate, float Time, bool bLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_SetTimerDelegate");
|
|
|
|
UKismetSystemLibrary_K2_SetTimerDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
params.Time = Time;
|
|
params.bLooping = bLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_SetTimer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimerHandle UKismetSystemLibrary::K2_SetTimer(class UObject* Object, const struct FString& FunctionName, float Time, bool bLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_SetTimer");
|
|
|
|
UKismetSystemLibrary_K2_SetTimer_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
params.Time = Time;
|
|
params.bLooping = bLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_PauseTimerHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
|
|
void UKismetSystemLibrary::K2_PauseTimerHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_PauseTimerHandle");
|
|
|
|
UKismetSystemLibrary_K2_PauseTimerHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_PauseTimerDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::K2_PauseTimerDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_PauseTimerDelegate");
|
|
|
|
UKismetSystemLibrary_K2_PauseTimerDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_PauseTimer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::K2_PauseTimer(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_PauseTimer");
|
|
|
|
UKismetSystemLibrary_K2_PauseTimer_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsValidTimerHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimerHandle Handle (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsValidTimerHandle(const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsValidTimerHandle");
|
|
|
|
UKismetSystemLibrary_K2_IsValidTimerHandle_Params params;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsTimerPausedHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsTimerPausedHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsTimerPausedHandle");
|
|
|
|
UKismetSystemLibrary_K2_IsTimerPausedHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsTimerPausedDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsTimerPausedDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsTimerPausedDelegate");
|
|
|
|
UKismetSystemLibrary_K2_IsTimerPausedDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsTimerPaused
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsTimerPaused(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsTimerPaused");
|
|
|
|
UKismetSystemLibrary_K2_IsTimerPaused_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsTimerActiveHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsTimerActiveHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsTimerActiveHandle");
|
|
|
|
UKismetSystemLibrary_K2_IsTimerActiveHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsTimerActiveDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsTimerActiveDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsTimerActiveDelegate");
|
|
|
|
UKismetSystemLibrary_K2_IsTimerActiveDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_IsTimerActive
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::K2_IsTimerActive(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_IsTimerActive");
|
|
|
|
UKismetSystemLibrary_K2_IsTimerActive_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_InvalidateTimerHandle
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FTimerHandle Handle (Parm, OutParm, ReferenceParm)
|
|
// struct FTimerHandle ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FTimerHandle UKismetSystemLibrary::K2_InvalidateTimerHandle(struct FTimerHandle* Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_InvalidateTimerHandle");
|
|
|
|
UKismetSystemLibrary_K2_InvalidateTimerHandle_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Handle != nullptr)
|
|
*Handle = params.Handle;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_GetTimerRemainingTimeHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::K2_GetTimerRemainingTimeHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_GetTimerRemainingTimeHandle");
|
|
|
|
UKismetSystemLibrary_K2_GetTimerRemainingTimeHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_GetTimerRemainingTimeDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::K2_GetTimerRemainingTimeDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_GetTimerRemainingTimeDelegate");
|
|
|
|
UKismetSystemLibrary_K2_GetTimerRemainingTimeDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_GetTimerRemainingTime
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::K2_GetTimerRemainingTime(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_GetTimerRemainingTime");
|
|
|
|
UKismetSystemLibrary_K2_GetTimerRemainingTime_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_GetTimerElapsedTimeHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::K2_GetTimerElapsedTimeHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_GetTimerElapsedTimeHandle");
|
|
|
|
UKismetSystemLibrary_K2_GetTimerElapsedTimeHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_GetTimerElapsedTimeDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::K2_GetTimerElapsedTimeDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_GetTimerElapsedTimeDelegate");
|
|
|
|
UKismetSystemLibrary_K2_GetTimerElapsedTimeDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_GetTimerElapsedTime
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::K2_GetTimerElapsedTime(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_GetTimerElapsedTime");
|
|
|
|
UKismetSystemLibrary_K2_GetTimerElapsedTime_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_ClearTimerHandle
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm)
|
|
|
|
void UKismetSystemLibrary::K2_ClearTimerHandle(class UObject* WorldContextObject, const struct FTimerHandle& Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_ClearTimerHandle");
|
|
|
|
UKismetSystemLibrary_K2_ClearTimerHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Handle = Handle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_ClearTimerDelegate
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FScriptDelegate Delegate (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::K2_ClearTimerDelegate(const struct FScriptDelegate& Delegate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_ClearTimerDelegate");
|
|
|
|
UKismetSystemLibrary_K2_ClearTimerDelegate_Params params;
|
|
params.Delegate = Delegate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_ClearTimer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString FunctionName (Parm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::K2_ClearTimer(class UObject* Object, const struct FString& FunctionName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_ClearTimer");
|
|
|
|
UKismetSystemLibrary_K2_ClearTimer_Params params;
|
|
params.Object = Object;
|
|
params.FunctionName = FunctionName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.K2_ClearAndInvalidateTimerHandle
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTimerHandle Handle (Parm, OutParm, ReferenceParm)
|
|
|
|
void UKismetSystemLibrary::K2_ClearAndInvalidateTimerHandle(class UObject* WorldContextObject, struct FTimerHandle* Handle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.K2_ClearAndInvalidateTimerHandle");
|
|
|
|
UKismetSystemLibrary_K2_ClearAndInvalidateTimerHandle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Handle != nullptr)
|
|
*Handle = params.Handle;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsValidSoftObjectReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsValidSoftObjectReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsValidSoftObjectReference");
|
|
|
|
UKismetSystemLibrary_IsValidSoftObjectReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsValidSoftClassReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsValidSoftClassReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsValidSoftClassReference");
|
|
|
|
UKismetSystemLibrary_IsValidSoftClassReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsValidPrimaryAssetType
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetType PrimaryAssetType (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsValidPrimaryAssetType(const struct FPrimaryAssetType& PrimaryAssetType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsValidPrimaryAssetType");
|
|
|
|
UKismetSystemLibrary_IsValidPrimaryAssetType_Params params;
|
|
params.PrimaryAssetType = PrimaryAssetType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsValidPrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsValidPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsValidPrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_IsValidPrimaryAssetId_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsValidClass
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* Class (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsValidClass(class UClass* Class)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsValidClass");
|
|
|
|
UKismetSystemLibrary_IsValidClass_Params params;
|
|
params.Class = Class;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsValid
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsValid(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsValid");
|
|
|
|
UKismetSystemLibrary_IsValid_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsStandalone
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsStandalone(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsStandalone");
|
|
|
|
UKismetSystemLibrary_IsStandalone_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsServer
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsServer(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsServer");
|
|
|
|
UKismetSystemLibrary_IsServer_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsPackagedForDistribution
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsPackagedForDistribution()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsPackagedForDistribution");
|
|
|
|
UKismetSystemLibrary_IsPackagedForDistribution_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsLoggedIn
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class APlayerController* SpecificPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsLoggedIn(class APlayerController* SpecificPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsLoggedIn");
|
|
|
|
UKismetSystemLibrary_IsLoggedIn_Params params;
|
|
params.SpecificPlayer = SpecificPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsInterstitialAdRequested
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsInterstitialAdRequested()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsInterstitialAdRequested");
|
|
|
|
UKismetSystemLibrary_IsInterstitialAdRequested_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsInterstitialAdAvailable
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsInterstitialAdAvailable()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsInterstitialAdAvailable");
|
|
|
|
UKismetSystemLibrary_IsInterstitialAdAvailable_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsDedicatedServer
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsDedicatedServer(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsDedicatedServer");
|
|
|
|
UKismetSystemLibrary_IsDedicatedServer_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.IsControllerAssignedToGamepad
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ControllerId (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::IsControllerAssignedToGamepad(int ControllerId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.IsControllerAssignedToGamepad");
|
|
|
|
UKismetSystemLibrary_IsControllerAssignedToGamepad_Params params;
|
|
params.ControllerId = ControllerId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.HideAdBanner
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::HideAdBanner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.HideAdBanner");
|
|
|
|
UKismetSystemLibrary_HideAdBanner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetVolumeButtonsHandledBySystem
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::GetVolumeButtonsHandledBySystem()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetVolumeButtonsHandledBySystem");
|
|
|
|
UKismetSystemLibrary_GetVolumeButtonsHandledBySystem_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetUniqueDeviceId
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetUniqueDeviceId()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetUniqueDeviceId");
|
|
|
|
UKismetSystemLibrary_GetUniqueDeviceId_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetSupportedFullscreenResolutions
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FIntPoint> Resolutions (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::GetSupportedFullscreenResolutions(TArray<struct FIntPoint>* Resolutions)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetSupportedFullscreenResolutions");
|
|
|
|
UKismetSystemLibrary_GetSupportedFullscreenResolutions_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Resolutions != nullptr)
|
|
*Resolutions = params.Resolutions;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetSoftObjectReferenceFromPrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
|
|
void UKismetSystemLibrary::GetSoftObjectReferenceFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetSoftObjectReferenceFromPrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_GetSoftObjectReferenceFromPrimaryAssetId_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetSoftClassReferenceFromPrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
|
|
void UKismetSystemLibrary::GetSoftClassReferenceFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetSoftClassReferenceFromPrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_GetSoftClassReferenceFromPrimaryAssetId_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetRenderingMaterialQualityLevel
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetSystemLibrary::GetRenderingMaterialQualityLevel()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetRenderingMaterialQualityLevel");
|
|
|
|
UKismetSystemLibrary_GetRenderingMaterialQualityLevel_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetRenderingDetailMode
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetSystemLibrary::GetRenderingDetailMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetRenderingDetailMode");
|
|
|
|
UKismetSystemLibrary_GetRenderingDetailMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPrimaryAssetsWithBundleState
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FName> RequiredBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FName> ExcludedBundles (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<struct FPrimaryAssetType> ValidTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bForceCurrentState (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FPrimaryAssetId> OutPrimaryAssetIdList (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::GetPrimaryAssetsWithBundleState(TArray<struct FName> RequiredBundles, TArray<struct FName> ExcludedBundles, TArray<struct FPrimaryAssetType> ValidTypes, bool bForceCurrentState, TArray<struct FPrimaryAssetId>* OutPrimaryAssetIdList)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPrimaryAssetsWithBundleState");
|
|
|
|
UKismetSystemLibrary_GetPrimaryAssetsWithBundleState_Params params;
|
|
params.RequiredBundles = RequiredBundles;
|
|
params.ExcludedBundles = ExcludedBundles;
|
|
params.ValidTypes = ValidTypes;
|
|
params.bForceCurrentState = bForceCurrentState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutPrimaryAssetIdList != nullptr)
|
|
*OutPrimaryAssetIdList = params.OutPrimaryAssetIdList;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPrimaryAssetIdList
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPrimaryAssetType PrimaryAssetType (Parm)
|
|
// TArray<struct FPrimaryAssetId> OutPrimaryAssetIdList (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::GetPrimaryAssetIdList(const struct FPrimaryAssetType& PrimaryAssetType, TArray<struct FPrimaryAssetId>* OutPrimaryAssetIdList)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPrimaryAssetIdList");
|
|
|
|
UKismetSystemLibrary_GetPrimaryAssetIdList_Params params;
|
|
params.PrimaryAssetType = PrimaryAssetType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutPrimaryAssetIdList != nullptr)
|
|
*OutPrimaryAssetIdList = params.OutPrimaryAssetIdList;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromSoftObjectReference
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FPrimaryAssetId UKismetSystemLibrary::GetPrimaryAssetIdFromSoftObjectReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromSoftObjectReference");
|
|
|
|
UKismetSystemLibrary_GetPrimaryAssetIdFromSoftObjectReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromSoftClassReference
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FPrimaryAssetId UKismetSystemLibrary::GetPrimaryAssetIdFromSoftClassReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromSoftClassReference");
|
|
|
|
UKismetSystemLibrary_GetPrimaryAssetIdFromSoftClassReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromObject
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPrimaryAssetId ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FPrimaryAssetId UKismetSystemLibrary::GetPrimaryAssetIdFromObject(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromObject");
|
|
|
|
UKismetSystemLibrary_GetPrimaryAssetIdFromObject_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromClass
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* Class (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPrimaryAssetId ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FPrimaryAssetId UKismetSystemLibrary::GetPrimaryAssetIdFromClass(class UClass* Class)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPrimaryAssetIdFromClass");
|
|
|
|
UKismetSystemLibrary_GetPrimaryAssetIdFromClass_Params params;
|
|
params.Class = Class;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPreferredLanguages
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FString> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
TArray<struct FString> UKismetSystemLibrary::GetPreferredLanguages()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPreferredLanguages");
|
|
|
|
UKismetSystemLibrary_GetPreferredLanguages_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPlatformUserName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetPlatformUserName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPlatformUserName");
|
|
|
|
UKismetSystemLibrary_GetPlatformUserName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetPathName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetPathName(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetPathName");
|
|
|
|
UKismetSystemLibrary_GetPathName_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetObjectName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetObjectName(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetObjectName");
|
|
|
|
UKismetSystemLibrary_GetObjectName_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetObjectFromPrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UObject* UKismetSystemLibrary::GetObjectFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetObjectFromPrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_GetObjectFromPrimaryAssetId_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetMinYResolutionForUI
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetSystemLibrary::GetMinYResolutionForUI()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetMinYResolutionForUI");
|
|
|
|
UKismetSystemLibrary_GetMinYResolutionForUI_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetMinYResolutionFor3DView
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetSystemLibrary::GetMinYResolutionFor3DView()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetMinYResolutionFor3DView");
|
|
|
|
UKismetSystemLibrary_GetMinYResolutionFor3DView_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetLocalCurrencySymbol
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetLocalCurrencySymbol()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetLocalCurrencySymbol");
|
|
|
|
UKismetSystemLibrary_GetLocalCurrencySymbol_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetLocalCurrencyCode
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetLocalCurrencyCode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetLocalCurrencyCode");
|
|
|
|
UKismetSystemLibrary_GetLocalCurrencyCode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetGameTimeInSeconds
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UKismetSystemLibrary::GetGameTimeInSeconds(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetGameTimeInSeconds");
|
|
|
|
UKismetSystemLibrary_GetGameTimeInSeconds_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetGameName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetGameName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetGameName");
|
|
|
|
UKismetSystemLibrary_GetGameName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetGameBundleId
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetGameBundleId()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetGameBundleId");
|
|
|
|
UKismetSystemLibrary_GetGameBundleId_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetEngineVersion
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetEngineVersion()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetEngineVersion");
|
|
|
|
UKismetSystemLibrary_GetEngineVersion_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetDisplayName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetDisplayName(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetDisplayName");
|
|
|
|
UKismetSystemLibrary_GetDisplayName_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetDeviceId
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetDeviceId()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetDeviceId");
|
|
|
|
UKismetSystemLibrary_GetDeviceId_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetDefaultLocale
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetDefaultLocale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetDefaultLocale");
|
|
|
|
UKismetSystemLibrary_GetDefaultLocale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetDefaultLanguage
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetDefaultLanguage()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetDefaultLanguage");
|
|
|
|
UKismetSystemLibrary_GetDefaultLanguage_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetCurrentBundleState
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
// bool bForceCurrentState (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FName> OutBundles (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::GetCurrentBundleState(const struct FPrimaryAssetId& PrimaryAssetId, bool bForceCurrentState, TArray<struct FName>* OutBundles)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetCurrentBundleState");
|
|
|
|
UKismetSystemLibrary_GetCurrentBundleState_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
params.bForceCurrentState = bForceCurrentState;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutBundles != nullptr)
|
|
*OutBundles = params.OutBundles;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetConvenientWindowedResolutions
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FIntPoint> Resolutions (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::GetConvenientWindowedResolutions(TArray<struct FIntPoint>* Resolutions)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetConvenientWindowedResolutions");
|
|
|
|
UKismetSystemLibrary_GetConvenientWindowedResolutions_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Resolutions != nullptr)
|
|
*Resolutions = params.Resolutions;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetComponentBounds
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class USceneComponent* Component (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FVector Origin (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, OutParm, IsPlainOldData)
|
|
// float SphereRadius (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::GetComponentBounds(class USceneComponent* Component, struct FVector* Origin, struct FVector* BoxExtent, float* SphereRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetComponentBounds");
|
|
|
|
UKismetSystemLibrary_GetComponentBounds_Params params;
|
|
params.Component = Component;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Origin != nullptr)
|
|
*Origin = params.Origin;
|
|
if (BoxExtent != nullptr)
|
|
*BoxExtent = params.BoxExtent;
|
|
if (SphereRadius != nullptr)
|
|
*SphereRadius = params.SphereRadius;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetCommandLine
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetCommandLine()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetCommandLine");
|
|
|
|
UKismetSystemLibrary_GetCommandLine_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetClassFromPrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
// class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UClass* UKismetSystemLibrary::GetClassFromPrimaryAssetId(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetClassFromPrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_GetClassFromPrimaryAssetId_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetClassDisplayName
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* Class (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::GetClassDisplayName(class UClass* Class)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetClassDisplayName");
|
|
|
|
UKismetSystemLibrary_GetClassDisplayName_Params params;
|
|
params.Class = Class;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetAdIDCount
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UKismetSystemLibrary::GetAdIDCount()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetAdIDCount");
|
|
|
|
UKismetSystemLibrary_GetAdIDCount_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetActorListFromComponentList
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<class UPrimitiveComponent*> ComponentList (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ActorClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> OutActorList (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::GetActorListFromComponentList(TArray<class UPrimitiveComponent*> ComponentList, class UClass* ActorClassFilter, TArray<class AActor*>* OutActorList)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetActorListFromComponentList");
|
|
|
|
UKismetSystemLibrary_GetActorListFromComponentList_Params params;
|
|
params.ComponentList = ComponentList;
|
|
params.ActorClassFilter = ActorClassFilter;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActorList != nullptr)
|
|
*OutActorList = params.OutActorList;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.GetActorBounds
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class AActor* Actor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::GetActorBounds(class AActor* Actor, struct FVector* Origin, struct FVector* BoxExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.GetActorBounds");
|
|
|
|
UKismetSystemLibrary_GetActorBounds_Params params;
|
|
params.Actor = Actor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Origin != nullptr)
|
|
*Origin = params.Origin;
|
|
if (BoxExtent != nullptr)
|
|
*BoxExtent = params.BoxExtent;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ForceCloseAdBanner
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::ForceCloseAdBanner()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ForceCloseAdBanner");
|
|
|
|
UKismetSystemLibrary_ForceCloseAdBanner_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.FlushPersistentDebugLines
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::FlushPersistentDebugLines(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.FlushPersistentDebugLines");
|
|
|
|
UKismetSystemLibrary_FlushPersistentDebugLines_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.FlushDebugStrings
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::FlushDebugStrings(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.FlushDebugStrings");
|
|
|
|
UKismetSystemLibrary_FlushDebugStrings_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ExecuteConsoleCommand
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Command (Parm, ZeroConstructor)
|
|
// class APlayerController* SpecificPlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::ExecuteConsoleCommand(class UObject* WorldContextObject, const struct FString& Command, class APlayerController* SpecificPlayer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ExecuteConsoleCommand");
|
|
|
|
UKismetSystemLibrary_ExecuteConsoleCommand_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Command = Command;
|
|
params.SpecificPlayer = SpecificPlayer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.EqualEqual_SoftObjectReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::EqualEqual_SoftObjectReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.EqualEqual_SoftObjectReference");
|
|
|
|
UKismetSystemLibrary_EqualEqual_SoftObjectReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.EqualEqual_SoftClassReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::EqualEqual_SoftClassReference()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.EqualEqual_SoftClassReference");
|
|
|
|
UKismetSystemLibrary_EqualEqual_SoftClassReference_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.EqualEqual_PrimaryAssetType
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetType A (Parm)
|
|
// struct FPrimaryAssetType B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::EqualEqual_PrimaryAssetType(const struct FPrimaryAssetType& A, const struct FPrimaryAssetType& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.EqualEqual_PrimaryAssetType");
|
|
|
|
UKismetSystemLibrary_EqualEqual_PrimaryAssetType_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.EqualEqual_PrimaryAssetId
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId A (Parm)
|
|
// struct FPrimaryAssetId B (Parm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::EqualEqual_PrimaryAssetId(const struct FPrimaryAssetId& A, const struct FPrimaryAssetId& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.EqualEqual_PrimaryAssetId");
|
|
|
|
UKismetSystemLibrary_EqualEqual_PrimaryAssetId_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector TextLocation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FString Text (Parm, ZeroConstructor)
|
|
// class AActor* TestBaseActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TextColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugString(class UObject* WorldContextObject, const struct FVector& TextLocation, const struct FString& Text, class AActor* TestBaseActor, const struct FLinearColor& TextColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugString");
|
|
|
|
UKismetSystemLibrary_DrawDebugString_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.TextLocation = TextLocation;
|
|
params.Text = Text;
|
|
params.TestBaseActor = TestBaseActor;
|
|
params.TextColor = TextColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugSphere
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Center (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Segments (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugSphere(class UObject* WorldContextObject, const struct FVector& Center, float Radius, int Segments, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugSphere");
|
|
|
|
UKismetSystemLibrary_DrawDebugSphere_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Center = Center;
|
|
params.Radius = Radius;
|
|
params.Segments = Segments;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugPoint
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Position (ConstParm, Parm, IsPlainOldData)
|
|
// float Size (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor PointColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugPoint(class UObject* WorldContextObject, const struct FVector& Position, float Size, const struct FLinearColor& PointColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugPoint");
|
|
|
|
UKismetSystemLibrary_DrawDebugPoint_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Position = Position;
|
|
params.Size = Size;
|
|
params.PointColor = PointColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugPlane
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPlane PlaneCoordinates (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector Location (ConstParm, Parm, IsPlainOldData)
|
|
// float Size (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor PlaneColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugPlane(class UObject* WorldContextObject, const struct FPlane& PlaneCoordinates, const struct FVector& Location, float Size, const struct FLinearColor& PlaneColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugPlane");
|
|
|
|
UKismetSystemLibrary_DrawDebugPlane_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PlaneCoordinates = PlaneCoordinates;
|
|
params.Location = Location;
|
|
params.Size = Size;
|
|
params.PlaneColor = PlaneColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugLine
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector LineStart (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector LineEnd (ConstParm, Parm, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugLine(class UObject* WorldContextObject, const struct FVector& LineStart, const struct FVector& LineEnd, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugLine");
|
|
|
|
UKismetSystemLibrary_DrawDebugLine_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.LineStart = LineStart;
|
|
params.LineEnd = LineEnd;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugFrustum
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform FrustumTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FLinearColor FrustumColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugFrustum(class UObject* WorldContextObject, const struct FTransform& FrustumTransform, const struct FLinearColor& FrustumColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugFrustum");
|
|
|
|
UKismetSystemLibrary_DrawDebugFrustum_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.FrustumTransform = FrustumTransform;
|
|
params.FrustumColor = FrustumColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugFloatHistoryTransform
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDebugFloatHistory FloatHistory (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FTransform DrawTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector2D DrawSize (Parm, IsPlainOldData)
|
|
// struct FLinearColor DrawColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugFloatHistoryTransform(class UObject* WorldContextObject, const struct FDebugFloatHistory& FloatHistory, const struct FTransform& DrawTransform, const struct FVector2D& DrawSize, const struct FLinearColor& DrawColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugFloatHistoryTransform");
|
|
|
|
UKismetSystemLibrary_DrawDebugFloatHistoryTransform_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.FloatHistory = FloatHistory;
|
|
params.DrawTransform = DrawTransform;
|
|
params.DrawSize = DrawSize;
|
|
params.DrawColor = DrawColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugFloatHistoryLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDebugFloatHistory FloatHistory (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FVector DrawLocation (Parm, IsPlainOldData)
|
|
// struct FVector2D DrawSize (Parm, IsPlainOldData)
|
|
// struct FLinearColor DrawColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugFloatHistoryLocation(class UObject* WorldContextObject, const struct FDebugFloatHistory& FloatHistory, const struct FVector& DrawLocation, const struct FVector2D& DrawSize, const struct FLinearColor& DrawColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugFloatHistoryLocation");
|
|
|
|
UKismetSystemLibrary_DrawDebugFloatHistoryLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.FloatHistory = FloatHistory;
|
|
params.DrawLocation = DrawLocation;
|
|
params.DrawSize = DrawSize;
|
|
params.DrawColor = DrawColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugCylinder
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int Segments (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugCylinder(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, int Segments, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugCylinder");
|
|
|
|
UKismetSystemLibrary_DrawDebugCylinder_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.Segments = Segments;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugCoordinateSystem
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector AxisLoc (ConstParm, Parm, IsPlainOldData)
|
|
// struct FRotator AxisRot (ConstParm, Parm, IsPlainOldData)
|
|
// float Scale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugCoordinateSystem(class UObject* WorldContextObject, const struct FVector& AxisLoc, const struct FRotator& AxisRot, float Scale, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugCoordinateSystem");
|
|
|
|
UKismetSystemLibrary_DrawDebugCoordinateSystem_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.AxisLoc = AxisLoc;
|
|
params.AxisRot = AxisRot;
|
|
params.Scale = Scale;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugConeInDegrees
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector Direction (ConstParm, Parm, IsPlainOldData)
|
|
// float Length (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AngleWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AngleHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumSides (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugConeInDegrees(class UObject* WorldContextObject, const struct FVector& Origin, const struct FVector& Direction, float Length, float AngleWidth, float AngleHeight, int NumSides, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugConeInDegrees");
|
|
|
|
UKismetSystemLibrary_DrawDebugConeInDegrees_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Origin = Origin;
|
|
params.Direction = Direction;
|
|
params.Length = Length;
|
|
params.AngleWidth = AngleWidth;
|
|
params.AngleHeight = AngleHeight;
|
|
params.NumSides = NumSides;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugCone
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector Direction (ConstParm, Parm, IsPlainOldData)
|
|
// float Length (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AngleWidth (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AngleHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumSides (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugCone(class UObject* WorldContextObject, const struct FVector& Origin, const struct FVector& Direction, float Length, float AngleWidth, float AngleHeight, int NumSides, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugCone");
|
|
|
|
UKismetSystemLibrary_DrawDebugCone_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Origin = Origin;
|
|
params.Direction = Direction;
|
|
params.Length = Length;
|
|
params.AngleWidth = AngleWidth;
|
|
params.AngleHeight = AngleHeight;
|
|
params.NumSides = NumSides;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugCircle
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Center (Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int NumSegments (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector YAxis (Parm, IsPlainOldData)
|
|
// struct FVector ZAxis (Parm, IsPlainOldData)
|
|
// bool bDrawAxis (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugCircle(class UObject* WorldContextObject, const struct FVector& Center, float Radius, int NumSegments, const struct FLinearColor& LineColor, float Duration, float Thickness, const struct FVector& YAxis, const struct FVector& ZAxis, bool bDrawAxis)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugCircle");
|
|
|
|
UKismetSystemLibrary_DrawDebugCircle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Center = Center;
|
|
params.Radius = Radius;
|
|
params.NumSegments = NumSegments;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
params.YAxis = YAxis;
|
|
params.ZAxis = ZAxis;
|
|
params.bDrawAxis = bDrawAxis;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugCapsule
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Center (ConstParm, Parm, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator Rotation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugCapsule(class UObject* WorldContextObject, const struct FVector& Center, float HalfHeight, float Radius, const struct FRotator& Rotation, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugCapsule");
|
|
|
|
UKismetSystemLibrary_DrawDebugCapsule_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Center = Center;
|
|
params.HalfHeight = HalfHeight;
|
|
params.Radius = Radius;
|
|
params.Rotation = Rotation;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugCamera
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class ACameraActor* CameraActor (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor CameraColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugCamera(class ACameraActor* CameraActor, const struct FLinearColor& CameraColor, float Duration)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugCamera");
|
|
|
|
UKismetSystemLibrary_DrawDebugCamera_Params params;
|
|
params.CameraActor = CameraActor;
|
|
params.CameraColor = CameraColor;
|
|
params.Duration = Duration;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugBox
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Center (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector Extent (Parm, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (ConstParm, Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugBox(class UObject* WorldContextObject, const struct FVector& Center, const struct FVector& Extent, const struct FLinearColor& LineColor, const struct FRotator& Rotation, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugBox");
|
|
|
|
UKismetSystemLibrary_DrawDebugBox_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Center = Center;
|
|
params.Extent = Extent;
|
|
params.LineColor = LineColor;
|
|
params.Rotation = Rotation;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DrawDebugArrow
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector LineStart (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector LineEnd (ConstParm, Parm, IsPlainOldData)
|
|
// float ArrowSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor LineColor (Parm, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Thickness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::DrawDebugArrow(class UObject* WorldContextObject, const struct FVector& LineStart, const struct FVector& LineEnd, float ArrowSize, const struct FLinearColor& LineColor, float Duration, float Thickness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DrawDebugArrow");
|
|
|
|
UKismetSystemLibrary_DrawDebugArrow_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.LineStart = LineStart;
|
|
params.LineEnd = LineEnd;
|
|
params.ArrowSize = ArrowSize;
|
|
params.LineColor = LineColor;
|
|
params.Duration = Duration;
|
|
params.Thickness = Thickness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.DoesImplementInterface
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* TestObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* Interface (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::DoesImplementInterface(class UObject* TestObject, class UClass* Interface)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.DoesImplementInterface");
|
|
|
|
UKismetSystemLibrary_DoesImplementInterface_Params params;
|
|
params.TestObject = TestObject;
|
|
params.Interface = Interface;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Delay
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLatentActionInfo LatentInfo (Parm)
|
|
|
|
void UKismetSystemLibrary::Delay(class UObject* WorldContextObject, float Duration, const struct FLatentActionInfo& LatentInfo)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Delay");
|
|
|
|
UKismetSystemLibrary_Delay_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Duration = Duration;
|
|
params.LatentInfo = LatentInfo;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CreateCopyForUndoBuffer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* ObjectToModify (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::CreateCopyForUndoBuffer(class UObject* ObjectToModify)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CreateCopyForUndoBuffer");
|
|
|
|
UKismetSystemLibrary_CreateCopyForUndoBuffer_Params params;
|
|
params.ObjectToModify = ObjectToModify;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_SoftObjectReferenceToString
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::Conv_SoftObjectReferenceToString()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_SoftObjectReferenceToString");
|
|
|
|
UKismetSystemLibrary_Conv_SoftObjectReferenceToString_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_SoftObjectReferenceToObject
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UObject* UKismetSystemLibrary::Conv_SoftObjectReferenceToObject()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_SoftObjectReferenceToObject");
|
|
|
|
UKismetSystemLibrary_Conv_SoftObjectReferenceToObject_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_SoftClassReferenceToString
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::Conv_SoftClassReferenceToString()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_SoftClassReferenceToString");
|
|
|
|
UKismetSystemLibrary_Conv_SoftClassReferenceToString_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_SoftClassReferenceToClass
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UClass* UKismetSystemLibrary::Conv_SoftClassReferenceToClass()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_SoftClassReferenceToClass");
|
|
|
|
UKismetSystemLibrary_Conv_SoftClassReferenceToClass_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_PrimaryAssetTypeToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetType PrimaryAssetType (Parm)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::Conv_PrimaryAssetTypeToString(const struct FPrimaryAssetType& PrimaryAssetType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_PrimaryAssetTypeToString");
|
|
|
|
UKismetSystemLibrary_Conv_PrimaryAssetTypeToString_Params params;
|
|
params.PrimaryAssetType = PrimaryAssetType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_PrimaryAssetIdToString
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FPrimaryAssetId PrimaryAssetId (Parm)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetSystemLibrary::Conv_PrimaryAssetIdToString(const struct FPrimaryAssetId& PrimaryAssetId)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_PrimaryAssetIdToString");
|
|
|
|
UKismetSystemLibrary_Conv_PrimaryAssetIdToString_Params params;
|
|
params.PrimaryAssetId = PrimaryAssetId;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_ObjectToSoftObjectReference
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* Object (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::Conv_ObjectToSoftObjectReference(class UObject* Object)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_ObjectToSoftObjectReference");
|
|
|
|
UKismetSystemLibrary_Conv_ObjectToSoftObjectReference_Params params;
|
|
params.Object = Object;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_InterfaceToObject
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// TScriptInterface<class UInterface> Interface (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
// class UObject* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UObject* UKismetSystemLibrary::Conv_InterfaceToObject(const TScriptInterface<class UInterface>& Interface)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_InterfaceToObject");
|
|
|
|
UKismetSystemLibrary_Conv_InterfaceToObject_Params params;
|
|
params.Interface = Interface;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.Conv_ClassToSoftClassReference
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UClass* Class (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::Conv_ClassToSoftClassReference(class UClass* Class)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.Conv_ClassToSoftClassReference");
|
|
|
|
UKismetSystemLibrary_Conv_ClassToSoftClassReference_Params params;
|
|
params.Class = Class;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ControlScreensaver
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bAllowScreenSaver (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UKismetSystemLibrary::ControlScreensaver(bool bAllowScreenSaver)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ControlScreensaver");
|
|
|
|
UKismetSystemLibrary_ControlScreensaver_Params params;
|
|
params.bAllowScreenSaver = bAllowScreenSaver;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ComponentOverlapComponents
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FTransform ComponentTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ComponentClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class UPrimitiveComponent*> OutComponents (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::ComponentOverlapComponents(class UPrimitiveComponent* Component, const struct FTransform& ComponentTransform, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ComponentClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ComponentOverlapComponents");
|
|
|
|
UKismetSystemLibrary_ComponentOverlapComponents_Params params;
|
|
params.Component = Component;
|
|
params.ComponentTransform = ComponentTransform;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ComponentClassFilter = ComponentClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutComponents != nullptr)
|
|
*OutComponents = params.OutComponents;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.ComponentOverlapActors
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FTransform ComponentTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ActorClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::ComponentOverlapActors(class UPrimitiveComponent* Component, const struct FTransform& ComponentTransform, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ActorClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.ComponentOverlapActors");
|
|
|
|
UKismetSystemLibrary_ComponentOverlapActors_Params params;
|
|
params.Component = Component;
|
|
params.ComponentTransform = ComponentTransform;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ActorClassFilter = ActorClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CollectGarbage
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UKismetSystemLibrary::CollectGarbage()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CollectGarbage");
|
|
|
|
UKismetSystemLibrary_CollectGarbage_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleTraceSingleForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleTraceSingleForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, float HalfHeight, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleTraceSingleForObjects");
|
|
|
|
UKismetSystemLibrary_CapsuleTraceSingleForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleTraceSingleByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleTraceSingleByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, float HalfHeight, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleTraceSingleByProfile");
|
|
|
|
UKismetSystemLibrary_CapsuleTraceSingleByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleTraceSingle
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleTraceSingle(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, float HalfHeight, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleTraceSingle");
|
|
|
|
UKismetSystemLibrary_CapsuleTraceSingle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleTraceMultiForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleTraceMultiForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, float HalfHeight, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleTraceMultiForObjects");
|
|
|
|
UKismetSystemLibrary_CapsuleTraceMultiForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleTraceMultiByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleTraceMultiByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, float HalfHeight, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleTraceMultiByProfile");
|
|
|
|
UKismetSystemLibrary_CapsuleTraceMultiByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleTraceMulti
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleTraceMulti(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, float Radius, float HalfHeight, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleTraceMulti");
|
|
|
|
UKismetSystemLibrary_CapsuleTraceMulti_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleOverlapComponents
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector CapsulePos (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ComponentClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class UPrimitiveComponent*> OutComponents (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleOverlapComponents(class UObject* WorldContextObject, const struct FVector& CapsulePos, float Radius, float HalfHeight, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ComponentClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleOverlapComponents");
|
|
|
|
UKismetSystemLibrary_CapsuleOverlapComponents_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.CapsulePos = CapsulePos;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ComponentClassFilter = ComponentClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutComponents != nullptr)
|
|
*OutComponents = params.OutComponents;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CapsuleOverlapActors
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector CapsulePos (ConstParm, Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float HalfHeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ActorClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CapsuleOverlapActors(class UObject* WorldContextObject, const struct FVector& CapsulePos, float Radius, float HalfHeight, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ActorClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CapsuleOverlapActors");
|
|
|
|
UKismetSystemLibrary_CapsuleOverlapActors_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.CapsulePos = CapsulePos;
|
|
params.Radius = Radius;
|
|
params.HalfHeight = HalfHeight;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ActorClassFilter = ActorClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.CanLaunchURL
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::CanLaunchURL(const struct FString& URL)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.CanLaunchURL");
|
|
|
|
UKismetSystemLibrary_CanLaunchURL_Params params;
|
|
params.URL = URL;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BreakSoftObjectPath
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSoftObjectPath InSoftObjectPath (Parm)
|
|
// struct FString PathString (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UKismetSystemLibrary::BreakSoftObjectPath(const struct FSoftObjectPath& InSoftObjectPath, struct FString* PathString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BreakSoftObjectPath");
|
|
|
|
UKismetSystemLibrary_BreakSoftObjectPath_Params params;
|
|
params.InSoftObjectPath = InSoftObjectPath;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PathString != nullptr)
|
|
*PathString = params.PathString;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxTraceSingleForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector HalfSize (ConstParm, Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (ConstParm, Parm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxTraceSingleForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxTraceSingleForObjects");
|
|
|
|
UKismetSystemLibrary_BoxTraceSingleForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.HalfSize = HalfSize;
|
|
params.Orientation = Orientation;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxTraceSingleByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector HalfSize (ConstParm, Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxTraceSingleByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxTraceSingleByProfile");
|
|
|
|
UKismetSystemLibrary_BoxTraceSingleByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.HalfSize = HalfSize;
|
|
params.Orientation = Orientation;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxTraceSingle
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector HalfSize (ConstParm, Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (ConstParm, Parm, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FHitResult OutHit (Parm, OutParm, IsPlainOldData)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxTraceSingle(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, struct FHitResult* OutHit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxTraceSingle");
|
|
|
|
UKismetSystemLibrary_BoxTraceSingle_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.HalfSize = HalfSize;
|
|
params.Orientation = Orientation;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHit != nullptr)
|
|
*OutHit = params.OutHit;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxTraceMultiForObjects
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector HalfSize (ConstParm, Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (ConstParm, Parm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxTraceMultiForObjects(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxTraceMultiForObjects");
|
|
|
|
UKismetSystemLibrary_BoxTraceMultiForObjects_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.HalfSize = HalfSize;
|
|
params.Orientation = Orientation;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxTraceMultiByProfile
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector HalfSize (Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (ConstParm, Parm, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxTraceMultiByProfile(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, const struct FName& ProfileName, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxTraceMultiByProfile");
|
|
|
|
UKismetSystemLibrary_BoxTraceMultiByProfile_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.HalfSize = HalfSize;
|
|
params.Orientation = Orientation;
|
|
params.ProfileName = ProfileName;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxTraceMulti
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Start (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector End (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector HalfSize (Parm, IsPlainOldData)
|
|
// struct FRotator Orientation (ConstParm, Parm, IsPlainOldData)
|
|
// TEnumAsByte<ETraceTypeQuery> TraceChannel (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bTraceComplex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<EDrawDebugTrace> DrawDebugType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<struct FHitResult> OutHits (Parm, OutParm, ZeroConstructor)
|
|
// bool bIgnoreSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor TraceColor (Parm, IsPlainOldData)
|
|
// struct FLinearColor TraceHitColor (Parm, IsPlainOldData)
|
|
// float DrawTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxTraceMulti(class UObject* WorldContextObject, const struct FVector& Start, const struct FVector& End, const struct FVector& HalfSize, const struct FRotator& Orientation, TEnumAsByte<ETraceTypeQuery> TraceChannel, bool bTraceComplex, TArray<class AActor*> ActorsToIgnore, TEnumAsByte<EDrawDebugTrace> DrawDebugType, float DrawTime, bool bIgnoreSelf, const struct FLinearColor& TraceColor, const struct FLinearColor& TraceHitColor, TArray<struct FHitResult>* OutHits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxTraceMulti");
|
|
|
|
UKismetSystemLibrary_BoxTraceMulti_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Start = Start;
|
|
params.End = End;
|
|
params.HalfSize = HalfSize;
|
|
params.Orientation = Orientation;
|
|
params.TraceChannel = TraceChannel;
|
|
params.bTraceComplex = bTraceComplex;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
params.DrawDebugType = DrawDebugType;
|
|
params.bIgnoreSelf = bIgnoreSelf;
|
|
params.TraceColor = TraceColor;
|
|
params.TraceHitColor = TraceHitColor;
|
|
params.DrawTime = DrawTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutHits != nullptr)
|
|
*OutHits = params.OutHits;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxOverlapComponents
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector BoxPos (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector Extent (Parm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ComponentClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class UPrimitiveComponent*> OutComponents (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxOverlapComponents(class UObject* WorldContextObject, const struct FVector& BoxPos, const struct FVector& Extent, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ComponentClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class UPrimitiveComponent*>* OutComponents)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxOverlapComponents");
|
|
|
|
UKismetSystemLibrary_BoxOverlapComponents_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.BoxPos = BoxPos;
|
|
params.Extent = Extent;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ComponentClassFilter = ComponentClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutComponents != nullptr)
|
|
*OutComponents = params.OutComponents;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.BoxOverlapActors
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector BoxPos (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector BoxExtent (Parm, IsPlainOldData)
|
|
// TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// class UClass* ActorClassFilter (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TArray<class AActor*> ActorsToIgnore (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TArray<class AActor*> OutActors (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetSystemLibrary::BoxOverlapActors(class UObject* WorldContextObject, const struct FVector& BoxPos, const struct FVector& BoxExtent, TArray<TEnumAsByte<EObjectTypeQuery>> ObjectTypes, class UClass* ActorClassFilter, TArray<class AActor*> ActorsToIgnore, TArray<class AActor*>* OutActors)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.BoxOverlapActors");
|
|
|
|
UKismetSystemLibrary_BoxOverlapActors_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.BoxPos = BoxPos;
|
|
params.BoxExtent = BoxExtent;
|
|
params.ObjectTypes = ObjectTypes;
|
|
params.ActorClassFilter = ActorClassFilter;
|
|
params.ActorsToIgnore = ActorsToIgnore;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutActors != nullptr)
|
|
*OutActors = params.OutActors;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetSystemLibrary.AddFloatHistorySample
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDebugFloatHistory FloatHistory (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FDebugFloatHistory ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FDebugFloatHistory UKismetSystemLibrary::AddFloatHistorySample(float Value, const struct FDebugFloatHistory& FloatHistory)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetSystemLibrary.AddFloatHistorySample");
|
|
|
|
UKismetSystemLibrary_AddFloatHistorySample_Params params;
|
|
params.Value = Value;
|
|
params.FloatHistory = FloatHistory;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextTrimTrailing
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::TextTrimTrailing(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextTrimTrailing");
|
|
|
|
UKismetTextLibrary_TextTrimTrailing_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextTrimPrecedingAndTrailing
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::TextTrimPrecedingAndTrailing(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextTrimPrecedingAndTrailing");
|
|
|
|
UKismetTextLibrary_TextTrimPrecedingAndTrailing_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextTrimPreceding
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::TextTrimPreceding(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextTrimPreceding");
|
|
|
|
UKismetTextLibrary_TextTrimPreceding_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextToUpper
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::TextToUpper(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextToUpper");
|
|
|
|
UKismetTextLibrary_TextToUpper_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextToLower
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::TextToLower(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextToLower");
|
|
|
|
UKismetTextLibrary_TextToLower_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextIsTransient
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::TextIsTransient(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextIsTransient");
|
|
|
|
UKismetTextLibrary_TextIsTransient_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextIsFromStringTable
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText Text (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::TextIsFromStringTable(const struct FText& Text)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextIsFromStringTable");
|
|
|
|
UKismetTextLibrary_TextIsFromStringTable_Params params;
|
|
params.Text = Text;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextIsEmpty
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::TextIsEmpty(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextIsEmpty");
|
|
|
|
UKismetTextLibrary_TextIsEmpty_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextIsCultureInvariant
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::TextIsCultureInvariant(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextIsCultureInvariant");
|
|
|
|
UKismetTextLibrary_TextIsCultureInvariant_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.TextFromStringTable
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName TableId (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::TextFromStringTable(const struct FName& TableId, const struct FString& Key)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.TextFromStringTable");
|
|
|
|
UKismetTextLibrary_TextFromStringTable_Params params;
|
|
params.TableId = TableId;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.StringTableIdAndKeyFromText
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText Text (Parm)
|
|
// struct FName OutTableId (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString OutKey (Parm, OutParm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::StringTableIdAndKeyFromText(const struct FText& Text, struct FName* OutTableId, struct FString* OutKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.StringTableIdAndKeyFromText");
|
|
|
|
UKismetTextLibrary_StringTableIdAndKeyFromText_Params params;
|
|
params.Text = Text;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutTableId != nullptr)
|
|
*OutTableId = params.OutTableId;
|
|
if (OutKey != nullptr)
|
|
*OutKey = params.OutKey;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.NotEqual_TextText
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText A (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText B (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::NotEqual_TextText(const struct FText& A, const struct FText& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.NotEqual_TextText");
|
|
|
|
UKismetTextLibrary_NotEqual_TextText_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.NotEqual_IgnoreCase_TextText
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText A (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText B (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::NotEqual_IgnoreCase_TextText(const struct FText& A, const struct FText& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.NotEqual_IgnoreCase_TextText");
|
|
|
|
UKismetTextLibrary_NotEqual_IgnoreCase_TextText_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.GetEmptyText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::GetEmptyText()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.GetEmptyText");
|
|
|
|
UKismetTextLibrary_GetEmptyText_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Format
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InPattern (Parm)
|
|
// TArray<struct FFormatArgumentData> InArgs (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Format(const struct FText& InPattern, TArray<struct FFormatArgumentData> InArgs)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Format");
|
|
|
|
UKismetTextLibrary_Format_Params params;
|
|
params.InPattern = InPattern;
|
|
params.InArgs = InArgs;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.FindTextInLocalizationTable
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString Namespace (Parm, ZeroConstructor)
|
|
// struct FString Key (Parm, ZeroConstructor)
|
|
// struct FText OutText (Parm, OutParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::FindTextInLocalizationTable(const struct FString& Namespace, const struct FString& Key, struct FText* OutText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.FindTextInLocalizationTable");
|
|
|
|
UKismetTextLibrary_FindTextInLocalizationTable_Params params;
|
|
params.Namespace = Namespace;
|
|
params.Key = Key;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutText != nullptr)
|
|
*OutText = params.OutText;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.EqualEqual_TextText
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText A (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText B (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::EqualEqual_TextText(const struct FText& A, const struct FText& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.EqualEqual_TextText");
|
|
|
|
UKismetTextLibrary_EqualEqual_TextText_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.EqualEqual_IgnoreCase_TextText
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText A (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText B (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UKismetTextLibrary::EqualEqual_IgnoreCase_TextText(const struct FText& A, const struct FText& B)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.EqualEqual_IgnoreCase_TextText");
|
|
|
|
UKismetTextLibrary_EqualEqual_IgnoreCase_TextText_Params params;
|
|
params.A = A;
|
|
params.B = B;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_VectorToText
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector InVec (Parm, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_VectorToText(const struct FVector& InVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_VectorToText");
|
|
|
|
UKismetTextLibrary_Conv_VectorToText_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_Vector2dToText
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector2D InVec (Parm, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_Vector2dToText(const struct FVector2D& InVec)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_Vector2dToText");
|
|
|
|
UKismetTextLibrary_Conv_Vector2dToText_Params params;
|
|
params.InVec = InVec;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_TransformToText
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform InTrans (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_TransformToText(const struct FTransform& InTrans)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_TransformToText");
|
|
|
|
UKismetTextLibrary_Conv_TransformToText_Params params;
|
|
params.InTrans = InTrans;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_TextToString
|
|
// (Final, Native, Static, Public, HasOutParms, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FText InText (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UKismetTextLibrary::Conv_TextToString(const struct FText& InText)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_TextToString");
|
|
|
|
UKismetTextLibrary_Conv_TextToString_Params params;
|
|
params.InText = InText;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_StringToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FString inString (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_StringToText(const struct FString& inString)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_StringToText");
|
|
|
|
UKismetTextLibrary_Conv_StringToText_Params params;
|
|
params.inString = inString;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_RotatorToText
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FRotator InRot (Parm, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_RotatorToText(const struct FRotator& InRot)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_RotatorToText");
|
|
|
|
UKismetTextLibrary_Conv_RotatorToText_Params params;
|
|
params.InRot = InRot;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_ObjectToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* InObj (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_ObjectToText(class UObject* InObj)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_ObjectToText");
|
|
|
|
UKismetTextLibrary_Conv_ObjectToText_Params params;
|
|
params.InObj = InObj;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_NameToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FName InName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_NameToText(const struct FName& InName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_NameToText");
|
|
|
|
UKismetTextLibrary_Conv_NameToText_Params params;
|
|
params.InName = InName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_IntToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseGrouping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_IntToText(int Value, bool bUseGrouping, int MinimumIntegralDigits, int MaximumIntegralDigits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_IntToText");
|
|
|
|
UKismetTextLibrary_Conv_IntToText_Params params;
|
|
params.Value = Value;
|
|
params.bUseGrouping = bUseGrouping;
|
|
params.MinimumIntegralDigits = MinimumIntegralDigits;
|
|
params.MaximumIntegralDigits = MaximumIntegralDigits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_FloatToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERoundingMode> RoundingMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseGrouping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_FloatToText(float Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bUseGrouping, int MinimumIntegralDigits, int MaximumIntegralDigits, int MinimumFractionalDigits, int MaximumFractionalDigits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_FloatToText");
|
|
|
|
UKismetTextLibrary_Conv_FloatToText_Params params;
|
|
params.Value = Value;
|
|
params.RoundingMode = RoundingMode;
|
|
params.bUseGrouping = bUseGrouping;
|
|
params.MinimumIntegralDigits = MinimumIntegralDigits;
|
|
params.MaximumIntegralDigits = MaximumIntegralDigits;
|
|
params.MinimumFractionalDigits = MinimumFractionalDigits;
|
|
params.MaximumFractionalDigits = MaximumFractionalDigits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_ColorToText
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinearColor InColor (Parm, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_ColorToText(const struct FLinearColor& InColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_ColorToText");
|
|
|
|
UKismetTextLibrary_Conv_ColorToText_Params params;
|
|
params.InColor = InColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_ByteToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// unsigned char Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_ByteToText(unsigned char Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_ByteToText");
|
|
|
|
UKismetTextLibrary_Conv_ByteToText_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.Conv_BoolToText
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// bool InBool (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::Conv_BoolToText(bool InBool)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.Conv_BoolToText");
|
|
|
|
UKismetTextLibrary_Conv_BoolToText_Params params;
|
|
params.InBool = InBool;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsTimeZoneTime_DateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime InDateTime (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString InTimeZone (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsTimeZoneTime_DateTime(const struct FDateTime& InDateTime, const struct FString& InTimeZone)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsTimeZoneTime_DateTime");
|
|
|
|
UKismetTextLibrary_AsTimeZoneTime_DateTime_Params params;
|
|
params.InDateTime = InDateTime;
|
|
params.InTimeZone = InTimeZone;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsTimeZoneDateTime_DateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime InDateTime (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString InTimeZone (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsTimeZoneDateTime_DateTime(const struct FDateTime& InDateTime, const struct FString& InTimeZone)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsTimeZoneDateTime_DateTime");
|
|
|
|
UKismetTextLibrary_AsTimeZoneDateTime_DateTime_Params params;
|
|
params.InDateTime = InDateTime;
|
|
params.InTimeZone = InTimeZone;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsTimeZoneDate_DateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime InDateTime (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FString InTimeZone (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsTimeZoneDate_DateTime(const struct FDateTime& InDateTime, const struct FString& InTimeZone)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsTimeZoneDate_DateTime");
|
|
|
|
UKismetTextLibrary_AsTimeZoneDate_DateTime_Params params;
|
|
params.InDateTime = InDateTime;
|
|
params.InTimeZone = InTimeZone;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsTimespan_Timespan
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTimespan InTimespan (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsTimespan_Timespan(const struct FTimespan& InTimespan)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsTimespan_Timespan");
|
|
|
|
UKismetTextLibrary_AsTimespan_Timespan_Params params;
|
|
params.InTimespan = InTimespan;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsTime_DateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime In (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsTime_DateTime(const struct FDateTime& In)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsTime_DateTime");
|
|
|
|
UKismetTextLibrary_AsTime_DateTime_Params params;
|
|
params.In = In;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsPercent_Float
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERoundingMode> RoundingMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseGrouping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsPercent_Float(float Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bUseGrouping, int MinimumIntegralDigits, int MaximumIntegralDigits, int MinimumFractionalDigits, int MaximumFractionalDigits)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsPercent_Float");
|
|
|
|
UKismetTextLibrary_AsPercent_Float_Params params;
|
|
params.Value = Value;
|
|
params.RoundingMode = RoundingMode;
|
|
params.bUseGrouping = bUseGrouping;
|
|
params.MinimumIntegralDigits = MinimumIntegralDigits;
|
|
params.MaximumIntegralDigits = MaximumIntegralDigits;
|
|
params.MinimumFractionalDigits = MinimumFractionalDigits;
|
|
params.MaximumFractionalDigits = MaximumFractionalDigits;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsDateTime_DateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime In (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsDateTime_DateTime(const struct FDateTime& In)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsDateTime_DateTime");
|
|
|
|
UKismetTextLibrary_AsDateTime_DateTime_Params params;
|
|
params.In = In;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsDate_DateTime
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FDateTime InDateTime (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsDate_DateTime(const struct FDateTime& InDateTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsDate_DateTime");
|
|
|
|
UKismetTextLibrary_AsDate_DateTime_Params params;
|
|
params.InDateTime = InDateTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsCurrencyBase
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int BaseValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString CurrencyCode (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsCurrencyBase(int BaseValue, const struct FString& CurrencyCode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsCurrencyBase");
|
|
|
|
UKismetTextLibrary_AsCurrencyBase_Params params;
|
|
params.BaseValue = BaseValue;
|
|
params.CurrencyCode = CurrencyCode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsCurrency_Integer
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// int Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERoundingMode> RoundingMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseGrouping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString CurrencyCode (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsCurrency_Integer(int Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bUseGrouping, int MinimumIntegralDigits, int MaximumIntegralDigits, int MinimumFractionalDigits, int MaximumFractionalDigits, const struct FString& CurrencyCode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsCurrency_Integer");
|
|
|
|
UKismetTextLibrary_AsCurrency_Integer_Params params;
|
|
params.Value = Value;
|
|
params.RoundingMode = RoundingMode;
|
|
params.bUseGrouping = bUseGrouping;
|
|
params.MinimumIntegralDigits = MinimumIntegralDigits;
|
|
params.MaximumIntegralDigits = MaximumIntegralDigits;
|
|
params.MinimumFractionalDigits = MinimumFractionalDigits;
|
|
params.MaximumFractionalDigits = MaximumFractionalDigits;
|
|
params.CurrencyCode = CurrencyCode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.KismetTextLibrary.AsCurrency_Float
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ERoundingMode> RoundingMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseGrouping (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumIntegralDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MinimumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int MaximumFractionalDigits (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString CurrencyCode (Parm, ZeroConstructor)
|
|
// struct FText ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FText UKismetTextLibrary::AsCurrency_Float(float Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bUseGrouping, int MinimumIntegralDigits, int MaximumIntegralDigits, int MinimumFractionalDigits, int MaximumFractionalDigits, const struct FString& CurrencyCode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.KismetTextLibrary.AsCurrency_Float");
|
|
|
|
UKismetTextLibrary_AsCurrency_Float_Params params;
|
|
params.Value = Value;
|
|
params.RoundingMode = RoundingMode;
|
|
params.bUseGrouping = bUseGrouping;
|
|
params.MinimumIntegralDigits = MinimumIntegralDigits;
|
|
params.MaximumIntegralDigits = MaximumIntegralDigits;
|
|
params.MinimumFractionalDigits = MinimumFractionalDigits;
|
|
params.MaximumFractionalDigits = MaximumFractionalDigits;
|
|
params.CurrencyCode = CurrencyCode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelScriptActor.WorldOriginLocationChanged
|
|
// (Event, Public, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// struct FIntVector OldOriginLocation (Parm, IsPlainOldData)
|
|
// struct FIntVector NewOriginLocation (Parm, IsPlainOldData)
|
|
|
|
void ALevelScriptActor::WorldOriginLocationChanged(const struct FIntVector& OldOriginLocation, const struct FIntVector& NewOriginLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelScriptActor.WorldOriginLocationChanged");
|
|
|
|
ALevelScriptActor_WorldOriginLocationChanged_Params params;
|
|
params.OldOriginLocation = OldOriginLocation;
|
|
params.NewOriginLocation = NewOriginLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelScriptActor.SetCinematicMode
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bCinematicMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bHidePlayer (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsHUD (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsMovement (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bAffectsTurning (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ALevelScriptActor::SetCinematicMode(bool bCinematicMode, bool bHidePlayer, bool bAffectsHUD, bool bAffectsMovement, bool bAffectsTurning)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelScriptActor.SetCinematicMode");
|
|
|
|
ALevelScriptActor_SetCinematicMode_Params params;
|
|
params.bCinematicMode = bCinematicMode;
|
|
params.bHidePlayer = bHidePlayer;
|
|
params.bAffectsHUD = bAffectsHUD;
|
|
params.bAffectsMovement = bAffectsMovement;
|
|
params.bAffectsTurning = bAffectsTurning;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelScriptActor.RemoteEvent
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName EventName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ALevelScriptActor::RemoteEvent(const struct FName& EventName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelScriptActor.RemoteEvent");
|
|
|
|
ALevelScriptActor_RemoteEvent_Params params;
|
|
params.EventName = EventName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelScriptActor.LevelReset
|
|
// (BlueprintAuthorityOnly, Event, Public, BlueprintEvent)
|
|
|
|
void ALevelScriptActor::LevelReset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelScriptActor.LevelReset");
|
|
|
|
ALevelScriptActor_LevelReset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreaming.IsStreamingStatePending
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ULevelStreaming::IsStreamingStatePending()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreaming.IsStreamingStatePending");
|
|
|
|
ULevelStreaming_IsStreamingStatePending_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreaming.IsLevelVisible
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ULevelStreaming::IsLevelVisible()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreaming.IsLevelVisible");
|
|
|
|
ULevelStreaming_IsLevelVisible_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreaming.IsLevelLoaded
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ULevelStreaming::IsLevelLoaded()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreaming.IsLevelLoaded");
|
|
|
|
ULevelStreaming_IsLevelLoaded_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreaming.GetWorldAssetPackageFName
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
struct FName ULevelStreaming::GetWorldAssetPackageFName()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreaming.GetWorldAssetPackageFName");
|
|
|
|
ULevelStreaming_GetWorldAssetPackageFName_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreaming.GetLevelScriptActor
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class ALevelScriptActor* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ALevelScriptActor* ULevelStreaming::GetLevelScriptActor()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreaming.GetLevelScriptActor");
|
|
|
|
ULevelStreaming_GetLevelScriptActor_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreaming.CreateInstance
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString UniqueInstanceName (Parm, ZeroConstructor)
|
|
// class ULevelStreaming* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULevelStreaming* ULevelStreaming::CreateInstance(const struct FString& UniqueInstanceName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreaming.CreateInstance");
|
|
|
|
ULevelStreaming_CreateInstance_Params params;
|
|
params.UniqueInstanceName = UniqueInstanceName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.LevelStreamingKismet.LoadLevelInstance
|
|
// (Final, RequiredAPI, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString LevelName (Parm, ZeroConstructor)
|
|
// struct FVector Location (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FRotator Rotation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bOutSuccess (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class ULevelStreamingKismet* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class ULevelStreamingKismet* ULevelStreamingKismet::LoadLevelInstance(class UObject* WorldContextObject, const struct FString& LevelName, const struct FVector& Location, const struct FRotator& Rotation, bool* bOutSuccess)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.LevelStreamingKismet.LoadLevelInstance");
|
|
|
|
ULevelStreamingKismet_LoadLevelInstance_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.LevelName = LevelName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (bOutSuccess != nullptr)
|
|
*bOutSuccess = params.bOutSuccess;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Texture2D.Blueprint_GetSizeY
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UTexture2D::Blueprint_GetSizeY()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Texture2D.Blueprint_GetSizeY");
|
|
|
|
UTexture2D_Blueprint_GetSizeY_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.Texture2D.Blueprint_GetSizeX
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UTexture2D::Blueprint_GetSizeX()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.Texture2D.Blueprint_GetSizeX");
|
|
|
|
UTexture2D_Blueprint_GetSizeX_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialBillboardComponent.SetElements
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FMaterialSpriteElement> NewElements (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void UMaterialBillboardComponent::SetElements(TArray<struct FMaterialSpriteElement> NewElements)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialBillboardComponent.SetElements");
|
|
|
|
UMaterialBillboardComponent_SetElements_Params params;
|
|
params.NewElements = NewElements;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialBillboardComponent.AddElement
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCurveFloat* DistanceToOpacityCurve (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bSizeIsInScreenSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BaseSizeX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float BaseSizeY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UCurveFloat* DistanceToSizeCurve (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialBillboardComponent::AddElement(class UMaterialInterface* Material, class UCurveFloat* DistanceToOpacityCurve, bool bSizeIsInScreenSpace, float BaseSizeX, float BaseSizeY, class UCurveFloat* DistanceToSizeCurve)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialBillboardComponent.AddElement");
|
|
|
|
UMaterialBillboardComponent_AddElement_Params params;
|
|
params.Material = Material;
|
|
params.DistanceToOpacityCurve = DistanceToOpacityCurve;
|
|
params.bSizeIsInScreenSpace = bSizeIsInScreenSpace;
|
|
params.BaseSizeX = BaseSizeX;
|
|
params.BaseSizeY = BaseSizeY;
|
|
params.DistanceToSizeCurve = DistanceToSizeCurve;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.SetVectorParameterValue
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor Value (Parm, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::SetVectorParameterValue(const struct FName& ParameterName, const struct FLinearColor& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.SetVectorParameterValue");
|
|
|
|
UMaterialInstanceDynamic_SetVectorParameterValue_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.SetTextureParameterValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::SetTextureParameterValue(const struct FName& ParameterName, class UTexture* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.SetTextureParameterValue");
|
|
|
|
UMaterialInstanceDynamic_SetTextureParameterValue_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.SetScalarParameterValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::SetScalarParameterValue(const struct FName& ParameterName, float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.SetScalarParameterValue");
|
|
|
|
UMaterialInstanceDynamic_SetScalarParameterValue_Params params;
|
|
params.ParameterName = ParameterName;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.K2_InterpolateMaterialInstanceParams
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInstance* SourceA (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInstance* SourceB (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float alpha (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::K2_InterpolateMaterialInstanceParams(class UMaterialInstance* SourceA, class UMaterialInstance* SourceB, float alpha)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.K2_InterpolateMaterialInstanceParams");
|
|
|
|
UMaterialInstanceDynamic_K2_InterpolateMaterialInstanceParams_Params params;
|
|
params.SourceA = SourceA;
|
|
params.SourceB = SourceB;
|
|
params.alpha = alpha;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.K2_GetVectorParameterValue
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FLinearColor UMaterialInstanceDynamic::K2_GetVectorParameterValue(const struct FName& ParameterName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.K2_GetVectorParameterValue");
|
|
|
|
UMaterialInstanceDynamic_K2_GetVectorParameterValue_Params params;
|
|
params.ParameterName = ParameterName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.K2_GetTextureParameterValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTexture* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UTexture* UMaterialInstanceDynamic::K2_GetTextureParameterValue(const struct FName& ParameterName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.K2_GetTextureParameterValue");
|
|
|
|
UMaterialInstanceDynamic_K2_GetTextureParameterValue_Params params;
|
|
params.ParameterName = ParameterName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.K2_GetScalarParameterValue
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName ParameterName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UMaterialInstanceDynamic::K2_GetScalarParameterValue(const struct FName& ParameterName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.K2_GetScalarParameterValue");
|
|
|
|
UMaterialInstanceDynamic_K2_GetScalarParameterValue_Params params;
|
|
params.ParameterName = ParameterName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.K2_CopyMaterialInstanceParameters
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Source (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::K2_CopyMaterialInstanceParameters(class UMaterialInterface* Source)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.K2_CopyMaterialInstanceParameters");
|
|
|
|
UMaterialInstanceDynamic_K2_CopyMaterialInstanceParameters_Params params;
|
|
params.Source = Source;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.CopyParameterOverrides
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInstance* MaterialInstance (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::CopyParameterOverrides(class UMaterialInstance* MaterialInstance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.CopyParameterOverrides");
|
|
|
|
UMaterialInstanceDynamic_CopyParameterOverrides_Params params;
|
|
params.MaterialInstance = MaterialInstance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MaterialInstanceDynamic.CopyInterpParameters
|
|
// (Final, Native, Public)
|
|
// Parameters:
|
|
// class UMaterialInstance* Source (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMaterialInstanceDynamic::CopyInterpParameters(class UMaterialInstance* Source)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MaterialInstanceDynamic.CopyInterpParameters");
|
|
|
|
UMaterialInstanceDynamic_CopyInterpParameters_Params params;
|
|
params.Source = Source;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.Stop
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AMatineeActor::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.Stop");
|
|
|
|
AMatineeActor_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.SetPosition
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bJump (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AMatineeActor::SetPosition(float NewPosition, bool bJump)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.SetPosition");
|
|
|
|
AMatineeActor_SetPosition_Params params;
|
|
params.NewPosition = NewPosition;
|
|
params.bJump = bJump;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.SetLoopingState
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AMatineeActor::SetLoopingState(bool bNewLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.SetLoopingState");
|
|
|
|
AMatineeActor_SetLoopingState_Params params;
|
|
params.bNewLooping = bNewLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.Reverse
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AMatineeActor::Reverse()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.Reverse");
|
|
|
|
AMatineeActor_Reverse_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.Play
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AMatineeActor::Play()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.Play");
|
|
|
|
AMatineeActor_Play_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.Pause
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AMatineeActor::Pause()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.Pause");
|
|
|
|
AMatineeActor_Pause_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.EnableGroupByName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString GroupName (Parm, ZeroConstructor)
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void AMatineeActor::EnableGroupByName(const struct FString& GroupName, bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.EnableGroupByName");
|
|
|
|
AMatineeActor_EnableGroupByName_Params params;
|
|
params.GroupName = GroupName;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MatineeActor.ChangePlaybackDirection
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void AMatineeActor::ChangePlaybackDirection()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MatineeActor.ChangePlaybackDirection");
|
|
|
|
AMatineeActor_ChangePlaybackDirection_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshVertexPainterKismetLibrary.RemovePaintedVertices
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UStaticMeshComponent* StaticMeshComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UMeshVertexPainterKismetLibrary::RemovePaintedVertices(class UStaticMeshComponent* StaticMeshComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshVertexPainterKismetLibrary.RemovePaintedVertices");
|
|
|
|
UMeshVertexPainterKismetLibrary_RemovePaintedVertices_Params params;
|
|
params.StaticMeshComponent = StaticMeshComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshVertexPainterKismetLibrary.PaintVerticesSingleColor
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UStaticMeshComponent* StaticMeshComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FLinearColor FillColor (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bConvertToSRGB (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMeshVertexPainterKismetLibrary::PaintVerticesSingleColor(class UStaticMeshComponent* StaticMeshComponent, const struct FLinearColor& FillColor, bool bConvertToSRGB)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshVertexPainterKismetLibrary.PaintVerticesSingleColor");
|
|
|
|
UMeshVertexPainterKismetLibrary_PaintVerticesSingleColor_Params params;
|
|
params.StaticMeshComponent = StaticMeshComponent;
|
|
params.FillColor = FillColor;
|
|
params.bConvertToSRGB = bConvertToSRGB;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.MeshVertexPainterKismetLibrary.PaintVerticesLerpAlongAxis
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UStaticMeshComponent* StaticMeshComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FLinearColor StartColor (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FLinearColor EndColor (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// EVertexPaintAxis Axis (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bConvertToSRGB (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UMeshVertexPainterKismetLibrary::PaintVerticesLerpAlongAxis(class UStaticMeshComponent* StaticMeshComponent, const struct FLinearColor& StartColor, const struct FLinearColor& EndColor, EVertexPaintAxis Axis, bool bConvertToSRGB)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.MeshVertexPainterKismetLibrary.PaintVerticesLerpAlongAxis");
|
|
|
|
UMeshVertexPainterKismetLibrary_PaintVerticesLerpAlongAxis_Params params;
|
|
params.StaticMeshComponent = StaticMeshComponent;
|
|
params.StartColor = StartColor;
|
|
params.EndColor = EndColor;
|
|
params.Axis = Axis;
|
|
params.bConvertToSRGB = bConvertToSRGB;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.IsValid
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationPath::IsValid()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.IsValid");
|
|
|
|
UNavigationPath_IsValid_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.IsStringPulled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationPath::IsStringPulled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.IsStringPulled");
|
|
|
|
UNavigationPath_IsStringPulled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.IsPartial
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationPath::IsPartial()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.IsPartial");
|
|
|
|
UNavigationPath_IsPartial_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.GetPathLength
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UNavigationPath::GetPathLength()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.GetPathLength");
|
|
|
|
UNavigationPath_GetPathLength_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.GetPathCost
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UNavigationPath::GetPathCost()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.GetPathCost");
|
|
|
|
UNavigationPath_GetPathCost_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.GetDebugString
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UNavigationPath::GetDebugString()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.GetDebugString");
|
|
|
|
UNavigationPath_GetDebugString_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.EnableRecalculationOnInvalidation
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ENavigationOptionFlag> DoRecalculation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationPath::EnableRecalculationOnInvalidation(TEnumAsByte<ENavigationOptionFlag> DoRecalculation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.EnableRecalculationOnInvalidation");
|
|
|
|
UNavigationPath_EnableRecalculationOnInvalidation_Params params;
|
|
params.DoRecalculation = DoRecalculation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationPath.EnableDebugDrawing
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bShouldDrawDebugData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FLinearColor PathColor (Parm, IsPlainOldData)
|
|
|
|
void UNavigationPath::EnableDebugDrawing(bool bShouldDrawDebugData, const struct FLinearColor& PathColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationPath.EnableDebugDrawing");
|
|
|
|
UNavigationPath_EnableDebugDrawing_Params params;
|
|
params.bShouldDrawDebugData = bShouldDrawDebugData;
|
|
params.PathColor = PathColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.UpdateDynamicGenerateTargetNav
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool IsAdd (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FDynamicGenerateTargetNavigation GenerateTargetNav (Parm)
|
|
|
|
void UNavigationSystem::UpdateDynamicGenerateTargetNav(bool IsAdd, const struct FDynamicGenerateTargetNavigation& GenerateTargetNav)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.UpdateDynamicGenerateTargetNav");
|
|
|
|
UNavigationSystem_UpdateDynamicGenerateTargetNav_Params params;
|
|
params.IsAdd = IsAdd;
|
|
params.GenerateTargetNav = GenerateTargetNav;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.UnregisterNavigationInvoker
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Invoker (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationSystem::UnregisterNavigationInvoker(class AActor* Invoker)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.UnregisterNavigationInvoker");
|
|
|
|
UNavigationSystem_UnregisterNavigationInvoker_Params params;
|
|
params.Invoker = Invoker;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.SimpleMoveToLocation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class AController* Controller (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Goal (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UNavigationSystem::SimpleMoveToLocation(class AController* Controller, const struct FVector& Goal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.SimpleMoveToLocation");
|
|
|
|
UNavigationSystem_SimpleMoveToLocation_Params params;
|
|
params.Controller = Controller;
|
|
params.Goal = Goal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.SimpleMoveToActor
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AController* Controller (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* Goal (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationSystem::SimpleMoveToActor(class AController* Controller, class AActor* Goal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.SimpleMoveToActor");
|
|
|
|
UNavigationSystem_SimpleMoveToActor_Params params;
|
|
params.Controller = Controller;
|
|
params.Goal = Goal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.SetMaxSimultaneousTileGenerationJobsCount
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int MaxNumberOfJobs (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationSystem::SetMaxSimultaneousTileGenerationJobsCount(int MaxNumberOfJobs)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.SetMaxSimultaneousTileGenerationJobsCount");
|
|
|
|
UNavigationSystem_SetMaxSimultaneousTileGenerationJobsCount_Params params;
|
|
params.MaxNumberOfJobs = MaxNumberOfJobs;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.SetGeometryGatheringMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// ENavDataGatheringModeConfig NewMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationSystem::SetGeometryGatheringMode(ENavDataGatheringModeConfig NewMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.SetGeometryGatheringMode");
|
|
|
|
UNavigationSystem_SetGeometryGatheringMode_Params params;
|
|
params.NewMode = NewMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.ResetMaxSimultaneousTileGenerationJobsCount
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UNavigationSystem::ResetMaxSimultaneousTileGenerationJobsCount()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.ResetMaxSimultaneousTileGenerationJobsCount");
|
|
|
|
UNavigationSystem_ResetMaxSimultaneousTileGenerationJobsCount_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.RegisterNavigationInvoker
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Invoker (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TileGenerationRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TileRemovalRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationSystem::RegisterNavigationInvoker(class AActor* Invoker, float TileGenerationRadius, float TileRemovalRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.RegisterNavigationInvoker");
|
|
|
|
UNavigationSystem_RegisterNavigationInvoker_Params params;
|
|
params.Invoker = Invoker;
|
|
params.TileGenerationRadius = TileGenerationRadius;
|
|
params.TileRemovalRadius = TileRemovalRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.ProjectPointToNavigation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Point (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector QueryExtent (ConstParm, Parm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UNavigationSystem::ProjectPointToNavigation(class UObject* WorldContextObject, const struct FVector& Point, class ANavigationData* NavData, class UClass* FilterClass, const struct FVector& QueryExtent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.ProjectPointToNavigation");
|
|
|
|
UNavigationSystem_ProjectPointToNavigation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Point = Point;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
params.QueryExtent = QueryExtent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.OnNavigationBoundsUpdated
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class ANavMeshBoundsVolume* NavVolume (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavigationSystem::OnNavigationBoundsUpdated(class ANavMeshBoundsVolume* NavVolume)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.OnNavigationBoundsUpdated");
|
|
|
|
UNavigationSystem_OnNavigationBoundsUpdated_Params params;
|
|
params.NavVolume = NavVolume;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.NavigationRaycast
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector RayStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector RayEnd (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector HitLocation (Parm, OutParm, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AController* Querier (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationSystem::NavigationRaycast(class UObject* WorldContextObject, const struct FVector& RayStart, const struct FVector& RayEnd, class UClass* FilterClass, class AController* Querier, struct FVector* HitLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.NavigationRaycast");
|
|
|
|
UNavigationSystem_NavigationRaycast_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.RayStart = RayStart;
|
|
params.RayEnd = RayEnd;
|
|
params.FilterClass = FilterClass;
|
|
params.Querier = Querier;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (HitLocation != nullptr)
|
|
*HitLocation = params.HitLocation;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.K2_ProjectPointToNavigation
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Point (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector ProjectedLocation (Parm, OutParm, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector QueryExtent (ConstParm, Parm, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationSystem::K2_ProjectPointToNavigation(class UObject* WorldContextObject, const struct FVector& Point, class ANavigationData* NavData, class UClass* FilterClass, const struct FVector& QueryExtent, struct FVector* ProjectedLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.K2_ProjectPointToNavigation");
|
|
|
|
UNavigationSystem_K2_ProjectPointToNavigation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Point = Point;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
params.QueryExtent = QueryExtent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (ProjectedLocation != nullptr)
|
|
*ProjectedLocation = params.ProjectedLocation;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.K2_GetRandomReachablePointInRadius
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector RandomLocation (Parm, OutParm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationSystem::K2_GetRandomReachablePointInRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, class ANavigationData* NavData, class UClass* FilterClass, struct FVector* RandomLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.K2_GetRandomReachablePointInRadius");
|
|
|
|
UNavigationSystem_K2_GetRandomReachablePointInRadius_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Origin = Origin;
|
|
params.Radius = Radius;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (RandomLocation != nullptr)
|
|
*RandomLocation = params.RandomLocation;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.K2_GetRandomPointInNavigableRadius
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector RandomLocation (Parm, OutParm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationSystem::K2_GetRandomPointInNavigableRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, class ANavigationData* NavData, class UClass* FilterClass, struct FVector* RandomLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.K2_GetRandomPointInNavigableRadius");
|
|
|
|
UNavigationSystem_K2_GetRandomPointInNavigableRadius_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Origin = Origin;
|
|
params.Radius = Radius;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (RandomLocation != nullptr)
|
|
*RandomLocation = params.RandomLocation;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.IsNavigationBeingBuiltOrLocked
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationSystem::IsNavigationBeingBuiltOrLocked(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.IsNavigationBeingBuiltOrLocked");
|
|
|
|
UNavigationSystem_IsNavigationBeingBuiltOrLocked_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.IsNavigationBeingBuilt
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UNavigationSystem::IsNavigationBeingBuilt(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.IsNavigationBeingBuilt");
|
|
|
|
UNavigationSystem_IsNavigationBeingBuilt_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.GetRandomReachablePointInRadius
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UNavigationSystem::GetRandomReachablePointInRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, class ANavigationData* NavData, class UClass* FilterClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.GetRandomReachablePointInRadius");
|
|
|
|
UNavigationSystem_GetRandomReachablePointInRadius_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Origin = Origin;
|
|
params.Radius = Radius;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.GetRandomPointInNavigableRadius
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Origin (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UNavigationSystem::GetRandomPointInNavigableRadius(class UObject* WorldContextObject, const struct FVector& Origin, float Radius, class ANavigationData* NavData, class UClass* FilterClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.GetRandomPointInNavigableRadius");
|
|
|
|
UNavigationSystem_GetRandomPointInNavigableRadius_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Origin = Origin;
|
|
params.Radius = Radius;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.GetPathLength
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector PathStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector PathEnd (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float PathLength (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ENavigationQueryResult> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ENavigationQueryResult> UNavigationSystem::GetPathLength(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, class ANavigationData* NavData, class UClass* FilterClass, float* PathLength)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.GetPathLength");
|
|
|
|
UNavigationSystem_GetPathLength_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PathStart = PathStart;
|
|
params.PathEnd = PathEnd;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PathLength != nullptr)
|
|
*PathLength = params.PathLength;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.GetPathCost
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector PathStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector PathEnd (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float PathCost (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class ANavigationData* NavData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ENavigationQueryResult> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ENavigationQueryResult> UNavigationSystem::GetPathCost(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, class ANavigationData* NavData, class UClass* FilterClass, float* PathCost)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.GetPathCost");
|
|
|
|
UNavigationSystem_GetPathCost_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PathStart = PathStart;
|
|
params.PathEnd = PathEnd;
|
|
params.NavData = NavData;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (PathCost != nullptr)
|
|
*PathCost = params.PathCost;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.GetNavigationSystem
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UNavigationSystem* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UNavigationSystem* UNavigationSystem::GetNavigationSystem(class UObject* WorldContextObject)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.GetNavigationSystem");
|
|
|
|
UNavigationSystem_GetNavigationSystem_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.FindPathToLocationSynchronously
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector PathStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector PathEnd (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class AActor* PathfindingContext (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UNavigationPath* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UNavigationPath* UNavigationSystem::FindPathToLocationSynchronously(class UObject* WorldContextObject, const struct FVector& PathStart, const struct FVector& PathEnd, class AActor* PathfindingContext, class UClass* FilterClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.FindPathToLocationSynchronously");
|
|
|
|
UNavigationSystem_FindPathToLocationSynchronously_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PathStart = PathStart;
|
|
params.PathEnd = PathEnd;
|
|
params.PathfindingContext = PathfindingContext;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavigationSystem.FindPathToActorSynchronously
|
|
// (Final, Native, Static, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector PathStart (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// class AActor* GoalActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TetherDistance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class AActor* PathfindingContext (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UClass* FilterClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UNavigationPath* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UNavigationPath* UNavigationSystem::FindPathToActorSynchronously(class UObject* WorldContextObject, const struct FVector& PathStart, class AActor* GoalActor, float TetherDistance, class AActor* PathfindingContext, class UClass* FilterClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavigationSystem.FindPathToActorSynchronously");
|
|
|
|
UNavigationSystem_FindPathToActorSynchronously_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.PathStart = PathStart;
|
|
params.GoalActor = GoalActor;
|
|
params.TetherDistance = TetherDistance;
|
|
params.PathfindingContext = PathfindingContext;
|
|
params.FilterClass = FilterClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavRelevantComponent.SetNavigationRelevancy
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bRelevant (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavRelevantComponent::SetNavigationRelevancy(bool bRelevant)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavRelevantComponent.SetNavigationRelevancy");
|
|
|
|
UNavRelevantComponent_SetNavigationRelevancy_Params params;
|
|
params.bRelevant = bRelevant;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavLinkProxy.SetSmartLinkEnabled
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ANavLinkProxy::SetSmartLinkEnabled(bool bEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavLinkProxy.SetSmartLinkEnabled");
|
|
|
|
ANavLinkProxy_SetSmartLinkEnabled_Params params;
|
|
params.bEnabled = bEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavLinkProxy.ResumePathFollowing
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* Agent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ANavLinkProxy::ResumePathFollowing(class AActor* Agent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavLinkProxy.ResumePathFollowing");
|
|
|
|
ANavLinkProxy_ResumePathFollowing_Params params;
|
|
params.Agent = Agent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavLinkProxy.ReceiveSmartLinkReached
|
|
// (Event, Public, HasOutParms, HasDefaults, BlueprintEvent)
|
|
// Parameters:
|
|
// class AActor* Agent (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Destination (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void ANavLinkProxy::ReceiveSmartLinkReached(class AActor* Agent, const struct FVector& Destination)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavLinkProxy.ReceiveSmartLinkReached");
|
|
|
|
ANavLinkProxy_ReceiveSmartLinkReached_Params params;
|
|
params.Agent = Agent;
|
|
params.Destination = Destination;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavLinkProxy.IsSmartLinkEnabled
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ANavLinkProxy::IsSmartLinkEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavLinkProxy.IsSmartLinkEnabled");
|
|
|
|
ANavLinkProxy_IsSmartLinkEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavLinkProxy.HasMovingAgents
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool ANavLinkProxy::HasMovingAgents()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavLinkProxy.HasMovingAgents");
|
|
|
|
ANavLinkProxy_HasMovingAgents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.NavModifierComponent.SetAreaClass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* NewAreaClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UNavModifierComponent::SetAreaClass(class UClass* NewAreaClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavModifierComponent.SetAreaClass");
|
|
|
|
UNavModifierComponent_SetAreaClass_Params params;
|
|
params.NewAreaClass = NewAreaClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.NavModifierVolume.SetAreaClass
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* NewAreaClass (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ANavModifierVolume::SetAreaClass(class UClass* NewAreaClass)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.NavModifierVolume.SetAreaClass");
|
|
|
|
ANavModifierVolume_SetAreaClass_Params params;
|
|
params.NewAreaClass = NewAreaClass;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ObjectPoolInterface.OnRespawned
|
|
// (Native, Public)
|
|
|
|
void UObjectPoolInterface::OnRespawned()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ObjectPoolInterface.OnRespawned");
|
|
|
|
UObjectPoolInterface_OnRespawned_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ObjectPoolInterface.OnRecycled
|
|
// (Native, Public)
|
|
|
|
void UObjectPoolInterface::OnRecycled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ObjectPoolInterface.OnRecycled");
|
|
|
|
UObjectPoolInterface_OnRecycled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ObjectPoolInterface.GetEnabled
|
|
// (Native, Public, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UObjectPoolInterface::GetEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ObjectPoolInterface.GetEnabled");
|
|
|
|
UObjectPoolInterface_GetEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.ObjectPoolInterface.GetDefaultPoolSize
|
|
// (Native, Public, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UObjectPoolInterface::GetDefaultPoolSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ObjectPoolInterface.GetDefaultPoolSize");
|
|
|
|
UObjectPoolInterface_GetDefaultPoolSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.OnlineBlueprintCallProxyBase.Activate
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void UOnlineBlueprintCallProxyBase::Activate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.OnlineBlueprintCallProxyBase.Activate");
|
|
|
|
UOnlineBlueprintCallProxyBase_Activate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.ParticleSystem.ContainsEmitterType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UClass* TypeData (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UParticleSystem::ContainsEmitterType(class UClass* TypeData)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.ParticleSystem.ContainsEmitterType");
|
|
|
|
UParticleSystem_ContainsEmitterType_Params params;
|
|
params.TypeData = TypeData;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PawnNoiseEmitterComponent.MakeNoise
|
|
// (BlueprintAuthorityOnly, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* NoiseMaker (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Loudness (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector NoiseLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPawnNoiseEmitterComponent::MakeNoise(class AActor* NoiseMaker, float Loudness, const struct FVector& NoiseLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PawnNoiseEmitterComponent.MakeNoise");
|
|
|
|
UPawnNoiseEmitterComponent_MakeNoise_Params params;
|
|
params.NoiseMaker = NoiseMaker;
|
|
params.Loudness = Loudness;
|
|
params.NoiseLocation = NoiseLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicalAnimationComponent.SetStrengthMultiplyer
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InStrengthMultiplyer (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicalAnimationComponent::SetStrengthMultiplyer(float InStrengthMultiplyer)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicalAnimationComponent.SetStrengthMultiplyer");
|
|
|
|
UPhysicalAnimationComponent_SetStrengthMultiplyer_Params params;
|
|
params.InStrengthMultiplyer = InStrengthMultiplyer;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicalAnimationComponent.SetSkeletalMeshComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* InSkeletalMeshComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UPhysicalAnimationComponent::SetSkeletalMeshComponent(class USkeletalMeshComponent* InSkeletalMeshComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicalAnimationComponent.SetSkeletalMeshComponent");
|
|
|
|
UPhysicalAnimationComponent_SetSkeletalMeshComponent_Params params;
|
|
params.InSkeletalMeshComponent = InSkeletalMeshComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicalAnimationComponent.GetBodyTargetTransform
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName BodyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UPhysicalAnimationComponent::GetBodyTargetTransform(const struct FName& BodyName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicalAnimationComponent.GetBodyTargetTransform");
|
|
|
|
UPhysicalAnimationComponent_GetBodyTargetTransform_Params params;
|
|
params.BodyName = BodyName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicalAnimationComponent.ApplyPhysicalAnimationSettingsBelow
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BodyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPhysicalAnimationData PhysicalAnimationData (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicalAnimationComponent::ApplyPhysicalAnimationSettingsBelow(const struct FName& BodyName, const struct FPhysicalAnimationData& PhysicalAnimationData, bool bIncludeSelf)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicalAnimationComponent.ApplyPhysicalAnimationSettingsBelow");
|
|
|
|
UPhysicalAnimationComponent_ApplyPhysicalAnimationSettingsBelow_Params params;
|
|
params.BodyName = BodyName;
|
|
params.PhysicalAnimationData = PhysicalAnimationData;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicalAnimationComponent.ApplyPhysicalAnimationSettings
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BodyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FPhysicalAnimationData PhysicalAnimationData (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UPhysicalAnimationComponent::ApplyPhysicalAnimationSettings(const struct FName& BodyName, const struct FPhysicalAnimationData& PhysicalAnimationData)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicalAnimationComponent.ApplyPhysicalAnimationSettings");
|
|
|
|
UPhysicalAnimationComponent_ApplyPhysicalAnimationSettings_Params params;
|
|
params.BodyName = BodyName;
|
|
params.PhysicalAnimationData = PhysicalAnimationData;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicalAnimationComponent.ApplyPhysicalAnimationProfileBelow
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BodyName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName ProfileName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bIncludeSelf (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bClearNotFound (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicalAnimationComponent::ApplyPhysicalAnimationProfileBelow(const struct FName& BodyName, const struct FName& ProfileName, bool bIncludeSelf, bool bClearNotFound)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicalAnimationComponent.ApplyPhysicalAnimationProfileBelow");
|
|
|
|
UPhysicalAnimationComponent_ApplyPhysicalAnimationProfileBelow_Params params;
|
|
params.BodyName = BodyName;
|
|
params.ProfileName = ProfileName;
|
|
params.bIncludeSelf = bIncludeSelf;
|
|
params.bClearNotFound = bClearNotFound;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetOrientationDriveTwistAndSwing
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableTwistDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableSwingDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetOrientationDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetOrientationDriveTwistAndSwing");
|
|
|
|
UPhysicsConstraintComponent_SetOrientationDriveTwistAndSwing_Params params;
|
|
params.bEnableTwistDrive = bEnableTwistDrive;
|
|
params.bEnableSwingDrive = bEnableSwingDrive;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetOrientationDriveSLERP
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableSLERP (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetOrientationDriveSLERP(bool bEnableSLERP)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetOrientationDriveSLERP");
|
|
|
|
UPhysicsConstraintComponent_SetOrientationDriveSLERP_Params params;
|
|
params.bEnableSLERP = bEnableSLERP;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearZLimit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ELinearConstraintMotion> ConstraintType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LimitSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearZLimit(TEnumAsByte<ELinearConstraintMotion> ConstraintType, float LimitSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearZLimit");
|
|
|
|
UPhysicsConstraintComponent_SetLinearZLimit_Params params;
|
|
params.ConstraintType = ConstraintType;
|
|
params.LimitSize = LimitSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearYLimit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ELinearConstraintMotion> ConstraintType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LimitSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearYLimit(TEnumAsByte<ELinearConstraintMotion> ConstraintType, float LimitSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearYLimit");
|
|
|
|
UPhysicsConstraintComponent_SetLinearYLimit_Params params;
|
|
params.ConstraintType = ConstraintType;
|
|
params.LimitSize = LimitSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearXLimit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ELinearConstraintMotion> ConstraintType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LimitSize (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearXLimit(TEnumAsByte<ELinearConstraintMotion> ConstraintType, float LimitSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearXLimit");
|
|
|
|
UPhysicsConstraintComponent_SetLinearXLimit_Params params;
|
|
params.ConstraintType = ConstraintType;
|
|
params.LimitSize = LimitSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearVelocityTarget
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector InVelTarget (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearVelocityTarget(const struct FVector& InVelTarget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearVelocityTarget");
|
|
|
|
UPhysicsConstraintComponent_SetLinearVelocityTarget_Params params;
|
|
params.InVelTarget = InVelTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearVelocityDrive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableDriveX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableDriveY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableDriveZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearVelocityDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearVelocityDrive");
|
|
|
|
UPhysicsConstraintComponent_SetLinearVelocityDrive_Params params;
|
|
params.bEnableDriveX = bEnableDriveX;
|
|
params.bEnableDriveY = bEnableDriveY;
|
|
params.bEnableDriveZ = bEnableDriveZ;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearPositionTarget
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector InPosTarget (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearPositionTarget(const struct FVector& InPosTarget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearPositionTarget");
|
|
|
|
UPhysicsConstraintComponent_SetLinearPositionTarget_Params params;
|
|
params.InPosTarget = InPosTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearPositionDrive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableDriveX (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableDriveY (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableDriveZ (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearPositionDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearPositionDrive");
|
|
|
|
UPhysicsConstraintComponent_SetLinearPositionDrive_Params params;
|
|
params.bEnableDriveX = bEnableDriveX;
|
|
params.bEnableDriveY = bEnableDriveY;
|
|
params.bEnableDriveZ = bEnableDriveZ;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearDriveParams
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float PositionStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VelocityStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InForceLimit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearDriveParams");
|
|
|
|
UPhysicsConstraintComponent_SetLinearDriveParams_Params params;
|
|
params.PositionStrength = PositionStrength;
|
|
params.VelocityStrength = VelocityStrength;
|
|
params.InForceLimit = InForceLimit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetLinearBreakable
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bLinearBreakable (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float LinearBreakThreshold (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetLinearBreakable(bool bLinearBreakable, float LinearBreakThreshold)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetLinearBreakable");
|
|
|
|
UPhysicsConstraintComponent_SetLinearBreakable_Params params;
|
|
params.bLinearBreakable = bLinearBreakable;
|
|
params.LinearBreakThreshold = LinearBreakThreshold;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetDisableCollision
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bDisableCollision (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetDisableCollision(bool bDisableCollision)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetDisableCollision");
|
|
|
|
UPhysicsConstraintComponent_SetDisableCollision_Params params;
|
|
params.bDisableCollision = bDisableCollision;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetConstraintReferencePosition
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EConstraintFrame> Frame (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector RefPosition (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetConstraintReferencePosition(TEnumAsByte<EConstraintFrame> Frame, const struct FVector& RefPosition)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetConstraintReferencePosition");
|
|
|
|
UPhysicsConstraintComponent_SetConstraintReferencePosition_Params params;
|
|
params.Frame = Frame;
|
|
params.RefPosition = RefPosition;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetConstraintReferenceOrientation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EConstraintFrame> Frame (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector PriAxis (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector SecAxis (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetConstraintReferenceOrientation(TEnumAsByte<EConstraintFrame> Frame, const struct FVector& PriAxis, const struct FVector& SecAxis)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetConstraintReferenceOrientation");
|
|
|
|
UPhysicsConstraintComponent_SetConstraintReferenceOrientation_Params params;
|
|
params.Frame = Frame;
|
|
params.PriAxis = PriAxis;
|
|
params.SecAxis = SecAxis;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetConstraintReferenceFrame
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EConstraintFrame> Frame (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform RefFrame (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetConstraintReferenceFrame(TEnumAsByte<EConstraintFrame> Frame, const struct FTransform& RefFrame)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetConstraintReferenceFrame");
|
|
|
|
UPhysicsConstraintComponent_SetConstraintReferenceFrame_Params params;
|
|
params.Frame = Frame;
|
|
params.RefFrame = RefFrame;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetConstrainedComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component1 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName BoneName1 (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UPrimitiveComponent* Component2 (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName BoneName2 (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetConstrainedComponents(class UPrimitiveComponent* Component1, const struct FName& BoneName1, class UPrimitiveComponent* Component2, const struct FName& BoneName2)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetConstrainedComponents");
|
|
|
|
UPhysicsConstraintComponent_SetConstrainedComponents_Params params;
|
|
params.Component1 = Component1;
|
|
params.BoneName1 = BoneName1;
|
|
params.Component2 = Component2;
|
|
params.BoneName2 = BoneName2;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularVelocityTarget
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector InVelTarget (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularVelocityTarget(const struct FVector& InVelTarget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularVelocityTarget");
|
|
|
|
UPhysicsConstraintComponent_SetAngularVelocityTarget_Params params;
|
|
params.InVelTarget = InVelTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularVelocityDriveTwistAndSwing
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableTwistDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableSwingDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularVelocityDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularVelocityDriveTwistAndSwing");
|
|
|
|
UPhysicsConstraintComponent_SetAngularVelocityDriveTwistAndSwing_Params params;
|
|
params.bEnableTwistDrive = bEnableTwistDrive;
|
|
params.bEnableSwingDrive = bEnableSwingDrive;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularVelocityDriveSLERP
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableSLERP (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularVelocityDriveSLERP(bool bEnableSLERP)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularVelocityDriveSLERP");
|
|
|
|
UPhysicsConstraintComponent_SetAngularVelocityDriveSLERP_Params params;
|
|
params.bEnableSLERP = bEnableSLERP;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularVelocityDrive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableSwingDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableTwistDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularVelocityDrive");
|
|
|
|
UPhysicsConstraintComponent_SetAngularVelocityDrive_Params params;
|
|
params.bEnableSwingDrive = bEnableSwingDrive;
|
|
params.bEnableTwistDrive = bEnableTwistDrive;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularTwistLimit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EAngularConstraintMotion> ConstraintType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float TwistLimitAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularTwistLimit(TEnumAsByte<EAngularConstraintMotion> ConstraintType, float TwistLimitAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularTwistLimit");
|
|
|
|
UPhysicsConstraintComponent_SetAngularTwistLimit_Params params;
|
|
params.ConstraintType = ConstraintType;
|
|
params.TwistLimitAngle = TwistLimitAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularSwing2Limit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EAngularConstraintMotion> MotionType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Swing2LimitAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularSwing2Limit(TEnumAsByte<EAngularConstraintMotion> MotionType, float Swing2LimitAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularSwing2Limit");
|
|
|
|
UPhysicsConstraintComponent_SetAngularSwing2Limit_Params params;
|
|
params.MotionType = MotionType;
|
|
params.Swing2LimitAngle = Swing2LimitAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularSwing1Limit
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EAngularConstraintMotion> MotionType (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Swing1LimitAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularSwing1Limit(TEnumAsByte<EAngularConstraintMotion> MotionType, float Swing1LimitAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularSwing1Limit");
|
|
|
|
UPhysicsConstraintComponent_SetAngularSwing1Limit_Params params;
|
|
params.MotionType = MotionType;
|
|
params.Swing1LimitAngle = Swing1LimitAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularOrientationTarget
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator InPosTarget (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularOrientationTarget(const struct FRotator& InPosTarget)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularOrientationTarget");
|
|
|
|
UPhysicsConstraintComponent_SetAngularOrientationTarget_Params params;
|
|
params.InPosTarget = InPosTarget;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularOrientationDrive
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnableSwingDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bEnableTwistDrive (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularOrientationDrive(bool bEnableSwingDrive, bool bEnableTwistDrive)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularOrientationDrive");
|
|
|
|
UPhysicsConstraintComponent_SetAngularOrientationDrive_Params params;
|
|
params.bEnableSwingDrive = bEnableSwingDrive;
|
|
params.bEnableTwistDrive = bEnableTwistDrive;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularDriveParams
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float PositionStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float VelocityStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InForceLimit (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularDriveParams");
|
|
|
|
UPhysicsConstraintComponent_SetAngularDriveParams_Params params;
|
|
params.PositionStrength = PositionStrength;
|
|
params.VelocityStrength = VelocityStrength;
|
|
params.InForceLimit = InForceLimit;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularDriveMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EAngularDriveMode> DriveMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularDriveMode(TEnumAsByte<EAngularDriveMode> DriveMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularDriveMode");
|
|
|
|
UPhysicsConstraintComponent_SetAngularDriveMode_Params params;
|
|
params.DriveMode = DriveMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.SetAngularBreakable
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bAngularBreakable (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float AngularBreakThreshold (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::SetAngularBreakable(bool bAngularBreakable, float AngularBreakThreshold)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.SetAngularBreakable");
|
|
|
|
UPhysicsConstraintComponent_SetAngularBreakable_Params params;
|
|
params.bAngularBreakable = bAngularBreakable;
|
|
params.AngularBreakThreshold = AngularBreakThreshold;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.IsBroken
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPhysicsConstraintComponent::IsBroken()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.IsBroken");
|
|
|
|
UPhysicsConstraintComponent_IsBroken_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.GetCurrentTwist
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPhysicsConstraintComponent::GetCurrentTwist()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.GetCurrentTwist");
|
|
|
|
UPhysicsConstraintComponent_GetCurrentTwist_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.GetCurrentSwing2
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPhysicsConstraintComponent::GetCurrentSwing2()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.GetCurrentSwing2");
|
|
|
|
UPhysicsConstraintComponent_GetCurrentSwing2_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.GetCurrentSwing1
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPhysicsConstraintComponent::GetCurrentSwing1()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.GetCurrentSwing1");
|
|
|
|
UPhysicsConstraintComponent_GetCurrentSwing1_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.GetConstraintForce
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector OutLinearForce (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector OutAngularForce (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UPhysicsConstraintComponent::GetConstraintForce(struct FVector* OutLinearForce, struct FVector* OutAngularForce)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.GetConstraintForce");
|
|
|
|
UPhysicsConstraintComponent_GetConstraintForce_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutLinearForce != nullptr)
|
|
*OutLinearForce = params.OutLinearForce;
|
|
if (OutAngularForce != nullptr)
|
|
*OutAngularForce = params.OutAngularForce;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsConstraintComponent.BreakConstraint
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UPhysicsConstraintComponent::BreakConstraint()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsConstraintComponent.BreakConstraint");
|
|
|
|
UPhysicsConstraintComponent_BreakConstraint_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetTargetRotation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetTargetRotation(const struct FRotator& NewRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetTargetRotation");
|
|
|
|
UPhysicsHandleComponent_SetTargetRotation_Params params;
|
|
params.NewRotation = NewRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetTargetLocationAndRotation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
// struct FRotator NewRotation (Parm, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetTargetLocationAndRotation(const struct FVector& NewLocation, const struct FRotator& NewRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetTargetLocationAndRotation");
|
|
|
|
UPhysicsHandleComponent_SetTargetLocationAndRotation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
params.NewRotation = NewRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetTargetLocation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector NewLocation (Parm, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetTargetLocation(const struct FVector& NewLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetTargetLocation");
|
|
|
|
UPhysicsHandleComponent_SetTargetLocation_Params params;
|
|
params.NewLocation = NewLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetLinearStiffness
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLinearStiffness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetLinearStiffness(float NewLinearStiffness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetLinearStiffness");
|
|
|
|
UPhysicsHandleComponent_SetLinearStiffness_Params params;
|
|
params.NewLinearStiffness = NewLinearStiffness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetLinearDamping
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLinearDamping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetLinearDamping(float NewLinearDamping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetLinearDamping");
|
|
|
|
UPhysicsHandleComponent_SetLinearDamping_Params params;
|
|
params.NewLinearDamping = NewLinearDamping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetInterpolationSpeed
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewInterpolationSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetInterpolationSpeed(float NewInterpolationSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetInterpolationSpeed");
|
|
|
|
UPhysicsHandleComponent_SetInterpolationSpeed_Params params;
|
|
params.NewInterpolationSpeed = NewInterpolationSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetAngularStiffness
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewAngularStiffness (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetAngularStiffness(float NewAngularStiffness)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetAngularStiffness");
|
|
|
|
UPhysicsHandleComponent_SetAngularStiffness_Params params;
|
|
params.NewAngularStiffness = NewAngularStiffness;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.SetAngularDamping
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewAngularDamping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::SetAngularDamping(float NewAngularDamping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.SetAngularDamping");
|
|
|
|
UPhysicsHandleComponent_SetAngularDamping_Params params;
|
|
params.NewAngularDamping = NewAngularDamping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.ReleaseComponent
|
|
// (RequiredAPI, Native, Public, BlueprintCallable)
|
|
|
|
void UPhysicsHandleComponent::ReleaseComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.ReleaseComponent");
|
|
|
|
UPhysicsHandleComponent_ReleaseComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.GrabComponentAtLocationWithRotation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName InBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FRotator Rotation (Parm, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::GrabComponentAtLocationWithRotation(class UPrimitiveComponent* Component, const struct FName& InBoneName, const struct FVector& Location, const struct FRotator& Rotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.GrabComponentAtLocationWithRotation");
|
|
|
|
UPhysicsHandleComponent_GrabComponentAtLocationWithRotation_Params params;
|
|
params.Component = Component;
|
|
params.InBoneName = InBoneName;
|
|
params.Location = Location;
|
|
params.Rotation = Rotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.GrabComponentAtLocation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName InBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector GrabLocation (Parm, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::GrabComponentAtLocation(class UPrimitiveComponent* Component, const struct FName& InBoneName, const struct FVector& GrabLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.GrabComponentAtLocation");
|
|
|
|
UPhysicsHandleComponent_GrabComponentAtLocation_Params params;
|
|
params.Component = Component;
|
|
params.InBoneName = InBoneName;
|
|
params.GrabLocation = GrabLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.GrabComponent
|
|
// (RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* Component (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FName InBoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector GrabLocation (Parm, IsPlainOldData)
|
|
// bool bConstrainRotation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::GrabComponent(class UPrimitiveComponent* Component, const struct FName& InBoneName, const struct FVector& GrabLocation, bool bConstrainRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.GrabComponent");
|
|
|
|
UPhysicsHandleComponent_GrabComponent_Params params;
|
|
params.Component = Component;
|
|
params.InBoneName = InBoneName;
|
|
params.GrabLocation = GrabLocation;
|
|
params.bConstrainRotation = bConstrainRotation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.GetTargetLocationAndRotation
|
|
// (Final, RequiredAPI, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector TargetLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FRotator TargetRotation (Parm, OutParm, IsPlainOldData)
|
|
|
|
void UPhysicsHandleComponent::GetTargetLocationAndRotation(struct FVector* TargetLocation, struct FRotator* TargetRotation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.GetTargetLocationAndRotation");
|
|
|
|
UPhysicsHandleComponent_GetTargetLocationAndRotation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (TargetLocation != nullptr)
|
|
*TargetLocation = params.TargetLocation;
|
|
if (TargetRotation != nullptr)
|
|
*TargetRotation = params.TargetRotation;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsHandleComponent.GetGrabbedComponent
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* ReturnValue (ExportObject, Parm, OutParm, ZeroConstructor, ReturnParm, InstancedReference, IsPlainOldData)
|
|
|
|
class UPrimitiveComponent* UPhysicsHandleComponent::GetGrabbedComponent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsHandleComponent.GetGrabbedComponent");
|
|
|
|
UPhysicsHandleComponent_GetGrabbedComponent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsSpringComponent.GetSpringRestingPoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPhysicsSpringComponent::GetSpringRestingPoint()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsSpringComponent.GetSpringRestingPoint");
|
|
|
|
UPhysicsSpringComponent_GetSpringRestingPoint_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsSpringComponent.GetSpringDirection
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPhysicsSpringComponent::GetSpringDirection()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsSpringComponent.GetSpringDirection");
|
|
|
|
UPhysicsSpringComponent_GetSpringDirection_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsSpringComponent.GetSpringCurrentEndPoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPhysicsSpringComponent::GetSpringCurrentEndPoint()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsSpringComponent.GetSpringCurrentEndPoint");
|
|
|
|
UPhysicsSpringComponent_GetSpringCurrentEndPoint_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PhysicsSpringComponent.GetNormalizedCompressionScalar
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UPhysicsSpringComponent::GetNormalizedCompressionScalar()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PhysicsSpringComponent.GetNormalizedCompressionScalar");
|
|
|
|
UPhysicsSpringComponent_GetNormalizedCompressionScalar_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlanarReflection.OnInterpToggle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APlanarReflection::OnInterpToggle(bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlanarReflection.OnInterpToggle");
|
|
|
|
APlanarReflection_OnInterpToggle_Params params;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.ShowOnlyComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* InComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::ShowOnlyComponent(class UPrimitiveComponent* InComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.ShowOnlyComponent");
|
|
|
|
USceneCaptureComponent_ShowOnlyComponent_Params params;
|
|
params.InComponent = InComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.ShowOnlyActorComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* InActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::ShowOnlyActorComponents(class AActor* InActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.ShowOnlyActorComponents");
|
|
|
|
USceneCaptureComponent_ShowOnlyActorComponents_Params params;
|
|
params.InActor = InActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.SetCaptureSortPriority
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int NewCaptureSortPriority (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::SetCaptureSortPriority(int NewCaptureSortPriority)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.SetCaptureSortPriority");
|
|
|
|
USceneCaptureComponent_SetCaptureSortPriority_Params params;
|
|
params.NewCaptureSortPriority = NewCaptureSortPriority;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.RemoveShowOnlyComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* InComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::RemoveShowOnlyComponent(class UPrimitiveComponent* InComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.RemoveShowOnlyComponent");
|
|
|
|
USceneCaptureComponent_RemoveShowOnlyComponent_Params params;
|
|
params.InComponent = InComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.RemoveShowOnlyActorComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* InActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::RemoveShowOnlyActorComponents(class AActor* InActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.RemoveShowOnlyActorComponents");
|
|
|
|
USceneCaptureComponent_RemoveShowOnlyActorComponents_Params params;
|
|
params.InActor = InActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.HideComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* InComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::HideComponent(class UPrimitiveComponent* InComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.HideComponent");
|
|
|
|
USceneCaptureComponent_HideComponent_Params params;
|
|
params.InComponent = InComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.HideActorComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class AActor* InActor (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::HideActorComponents(class AActor* InActor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.HideActorComponents");
|
|
|
|
USceneCaptureComponent_HideActorComponents_Params params;
|
|
params.InActor = InActor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.ClearShowOnlyComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UPrimitiveComponent* InComponent (Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent::ClearShowOnlyComponents(class UPrimitiveComponent* InComponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.ClearShowOnlyComponents");
|
|
|
|
USceneCaptureComponent_ClearShowOnlyComponents_Params params;
|
|
params.InComponent = InComponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent.ClearHiddenComponents
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USceneCaptureComponent::ClearHiddenComponents()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent.ClearHiddenComponents");
|
|
|
|
USceneCaptureComponent_ClearHiddenComponents_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlatformEventsComponent.SupportsConvertibleLaptops
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPlatformEventsComponent::SupportsConvertibleLaptops()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlatformEventsComponent.SupportsConvertibleLaptops");
|
|
|
|
UPlatformEventsComponent_SupportsConvertibleLaptops_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// DelegateFunction Engine.PlatformEventsComponent.PlatformEventDelegate__DelegateSignature
|
|
// (MulticastDelegate, Public, Delegate)
|
|
|
|
void UPlatformEventsComponent::PlatformEventDelegate__DelegateSignature()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("DelegateFunction Engine.PlatformEventsComponent.PlatformEventDelegate__DelegateSignature");
|
|
|
|
UPlatformEventsComponent_PlatformEventDelegate__DelegateSignature_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlatformEventsComponent.IsInTabletMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPlatformEventsComponent::IsInTabletMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlatformEventsComponent.IsInTabletMode");
|
|
|
|
UPlatformEventsComponent_IsInTabletMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlatformEventsComponent.IsInLaptopMode
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UPlatformEventsComponent::IsInLaptopMode()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlatformEventsComponent.IsInLaptopMode");
|
|
|
|
UPlatformEventsComponent_IsInLaptopMode_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlatformInterfaceWebResponse.GetNumHeaders
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UPlatformInterfaceWebResponse::GetNumHeaders()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlatformInterfaceWebResponse.GetNumHeaders");
|
|
|
|
UPlatformInterfaceWebResponse_GetNumHeaders_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlatformInterfaceWebResponse.GetHeaderValue
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// struct FString HeaderName (Parm, ZeroConstructor)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UPlatformInterfaceWebResponse::GetHeaderValue(const struct FString& HeaderName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlatformInterfaceWebResponse.GetHeaderValue");
|
|
|
|
UPlatformInterfaceWebResponse_GetHeaderValue_Params params;
|
|
params.HeaderName = HeaderName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PlatformInterfaceWebResponse.GetHeader
|
|
// (Native, Public, HasOutParms)
|
|
// Parameters:
|
|
// int HeaderIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Header (Parm, OutParm, ZeroConstructor)
|
|
// struct FString Value (Parm, OutParm, ZeroConstructor)
|
|
|
|
void UPlatformInterfaceWebResponse::GetHeader(int HeaderIndex, struct FString* Header, struct FString* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlatformInterfaceWebResponse.GetHeader");
|
|
|
|
UPlatformInterfaceWebResponse_GetHeader_Params params;
|
|
params.HeaderIndex = HeaderIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Header != nullptr)
|
|
*Header = params.Header;
|
|
if (Value != nullptr)
|
|
*Value = params.Value;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerInput.SetMouseSensitivity
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// float Sensitivity (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPlayerInput::SetMouseSensitivity(float Sensitivity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerInput.SetMouseSensitivity");
|
|
|
|
UPlayerInput_SetMouseSensitivity_Params params;
|
|
params.Sensitivity = Sensitivity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerInput.SetBind
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName BindName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Command (Parm, ZeroConstructor)
|
|
|
|
void UPlayerInput::SetBind(const struct FName& BindName, const struct FString& Command)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerInput.SetBind");
|
|
|
|
UPlayerInput_SetBind_Params params;
|
|
params.BindName = BindName;
|
|
params.Command = Command;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerInput.InvertAxisKey
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FKey AxisKey (ConstParm, Parm)
|
|
|
|
void UPlayerInput::InvertAxisKey(const struct FKey& AxisKey)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerInput.InvertAxisKey");
|
|
|
|
UPlayerInput_InvertAxisKey_Params params;
|
|
params.AxisKey = AxisKey;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerInput.InvertAxis
|
|
// (Final, Exec, Native, Public)
|
|
// Parameters:
|
|
// struct FName AxisName (ConstParm, Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPlayerInput::InvertAxis(const struct FName& AxisName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerInput.InvertAxis");
|
|
|
|
UPlayerInput_InvertAxis_Params params;
|
|
params.AxisName = AxisName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PlayerInput.ClearSmoothing
|
|
// (Final, Exec, Native, Public)
|
|
|
|
void UPlayerInput::ClearSmoothing()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PlayerInput.ClearSmoothing");
|
|
|
|
UPlayerInput_ClearSmoothing_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLight.SetRadius
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APointLight::SetRadius(float NewRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLight.SetRadius");
|
|
|
|
APointLight_SetRadius_Params params;
|
|
params.NewRadius = NewRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLight.SetLightFalloffExponent
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLightFalloffExponent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APointLight::SetLightFalloffExponent(float NewLightFalloffExponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLight.SetLightFalloffExponent");
|
|
|
|
APointLight_SetLightFalloffExponent_Params params;
|
|
params.NewLightFalloffExponent = NewLightFalloffExponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLightComponent.SetSourceRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPointLightComponent::SetSourceRadius(float bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLightComponent.SetSourceRadius");
|
|
|
|
UPointLightComponent_SetSourceRadius_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLightComponent.SetSourceLength
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPointLightComponent::SetSourceLength(float NewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLightComponent.SetSourceLength");
|
|
|
|
UPointLightComponent_SetSourceLength_Params params;
|
|
params.NewValue = NewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLightComponent.SetSoftSourceRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float bNewValue (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPointLightComponent::SetSoftSourceRadius(float bNewValue)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLightComponent.SetSoftSourceRadius");
|
|
|
|
UPointLightComponent_SetSoftSourceRadius_Params params;
|
|
params.bNewValue = bNewValue;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLightComponent.SetLightFalloffExponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLightFalloffExponent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPointLightComponent::SetLightFalloffExponent(float NewLightFalloffExponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLightComponent.SetLightFalloffExponent");
|
|
|
|
UPointLightComponent_SetLightFalloffExponent_Params params;
|
|
params.NewLightFalloffExponent = NewLightFalloffExponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PointLightComponent.SetAttenuationRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPointLightComponent::SetAttenuationRadius(float NewRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PointLightComponent.SetAttenuationRadius");
|
|
|
|
UPointLightComponent_SetAttenuationRadius_Params params;
|
|
params.NewRadius = NewRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.SetBoneTransformByName
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform InTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPoseableMeshComponent::SetBoneTransformByName(const struct FName& BoneName, const struct FTransform& InTransform, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.SetBoneTransformByName");
|
|
|
|
UPoseableMeshComponent_SetBoneTransformByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InTransform = InTransform;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.SetBoneScaleByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InScale3D (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPoseableMeshComponent::SetBoneScaleByName(const struct FName& BoneName, const struct FVector& InScale3D, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.SetBoneScaleByName");
|
|
|
|
UPoseableMeshComponent_SetBoneScaleByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InScale3D = InScale3D;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.SetBoneRotationByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator InRotation (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPoseableMeshComponent::SetBoneRotationByName(const struct FName& BoneName, const struct FRotator& InRotation, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.SetBoneRotationByName");
|
|
|
|
UPoseableMeshComponent_SetBoneRotationByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InRotation = InRotation;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.SetBoneLocationByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InLocation (Parm, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPoseableMeshComponent::SetBoneLocationByName(const struct FName& BoneName, const struct FVector& InLocation, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.SetBoneLocationByName");
|
|
|
|
UPoseableMeshComponent_SetBoneLocationByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.InLocation = InLocation;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.ResetBoneTransformByName
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPoseableMeshComponent::ResetBoneTransformByName(const struct FName& BoneName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.ResetBoneTransformByName");
|
|
|
|
UPoseableMeshComponent_ResetBoneTransformByName_Params params;
|
|
params.BoneName = BoneName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.GetBoneTransformByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform UPoseableMeshComponent::GetBoneTransformByName(const struct FName& BoneName, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.GetBoneTransformByName");
|
|
|
|
UPoseableMeshComponent_GetBoneTransformByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.GetBoneScaleByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPoseableMeshComponent::GetBoneScaleByName(const struct FName& BoneName, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.GetBoneScaleByName");
|
|
|
|
UPoseableMeshComponent_GetBoneScaleByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.GetBoneRotationByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator UPoseableMeshComponent::GetBoneRotationByName(const struct FName& BoneName, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.GetBoneRotationByName");
|
|
|
|
UPoseableMeshComponent_GetBoneRotationByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.GetBoneLocationByName
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FName BoneName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<EBoneSpaces> BoneSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UPoseableMeshComponent::GetBoneLocationByName(const struct FName& BoneName, TEnumAsByte<EBoneSpaces> BoneSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.GetBoneLocationByName");
|
|
|
|
UPoseableMeshComponent_GetBoneLocationByName_Params params;
|
|
params.BoneName = BoneName;
|
|
params.BoneSpace = BoneSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.PoseableMeshComponent.CopyPoseFromSkeletalComponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* InComponentToCopy (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
|
|
void UPoseableMeshComponent::CopyPoseFromSkeletalComponent(class USkeletalMeshComponent* InComponentToCopy)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PoseableMeshComponent.CopyPoseFromSkeletalComponent");
|
|
|
|
UPoseableMeshComponent_CopyPoseFromSkeletalComponent_Params params;
|
|
params.InComponentToCopy = InComponentToCopy;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PostProcessComponent.AddOrUpdateBlendable
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TScriptInterface<class UBlendableInterface> InBlendableObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UPostProcessComponent::AddOrUpdateBlendable(const TScriptInterface<class UBlendableInterface>& InBlendableObject, float InWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PostProcessComponent.AddOrUpdateBlendable");
|
|
|
|
UPostProcessComponent_AddOrUpdateBlendable_Params params;
|
|
params.InBlendableObject = InBlendableObject;
|
|
params.InWeight = InWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.PostProcessVolume.AddOrUpdateBlendable
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TScriptInterface<class UBlendableInterface> InBlendableObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void APostProcessVolume::AddOrUpdateBlendable(const TScriptInterface<class UBlendableInterface>& InBlendableObject, float InWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.PostProcessVolume.AddOrUpdateBlendable");
|
|
|
|
APostProcessVolume_AddOrUpdateBlendable_Params params;
|
|
params.InBlendableObject = InBlendableObject;
|
|
params.InWeight = InWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceActor.ToggleForce
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void ARadialForceActor::ToggleForce()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceActor.ToggleForce");
|
|
|
|
ARadialForceActor_ToggleForce_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceActor.FireImpulse
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void ARadialForceActor::FireImpulse()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceActor.FireImpulse");
|
|
|
|
ARadialForceActor_FireImpulse_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceActor.EnableForce
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void ARadialForceActor::EnableForce()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceActor.EnableForce");
|
|
|
|
ARadialForceActor_EnableForce_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceActor.DisableForce
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void ARadialForceActor::DisableForce()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceActor.DisableForce");
|
|
|
|
ARadialForceActor_DisableForce_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceComponent.RemoveObjectTypeToAffect
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EObjectTypeQuery> ObjectType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void URadialForceComponent::RemoveObjectTypeToAffect(TEnumAsByte<EObjectTypeQuery> ObjectType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceComponent.RemoveObjectTypeToAffect");
|
|
|
|
URadialForceComponent_RemoveObjectTypeToAffect_Params params;
|
|
params.ObjectType = ObjectType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceComponent.FireImpulse
|
|
// (Native, Public, BlueprintCallable)
|
|
|
|
void URadialForceComponent::FireImpulse()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceComponent.FireImpulse");
|
|
|
|
URadialForceComponent_FireImpulse_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.RadialForceComponent.AddObjectTypeToAffect
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EObjectTypeQuery> ObjectType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void URadialForceComponent::AddObjectTypeToAffect(TEnumAsByte<EObjectTypeQuery> ObjectType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.RadialForceComponent.AddObjectTypeToAffect");
|
|
|
|
URadialForceComponent_AddObjectTypeToAffect_Params params;
|
|
params.ObjectType = ObjectType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCapture2D.OnInterpToggle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ASceneCapture2D::OnInterpToggle(bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCapture2D.OnInterpToggle");
|
|
|
|
ASceneCapture2D_OnInterpToggle_Params params;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent2D.CaptureScene
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USceneCaptureComponent2D::CaptureScene()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent2D.CaptureScene");
|
|
|
|
USceneCaptureComponent2D_CaptureScene_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponent2D.AddOrUpdateBlendable
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TScriptInterface<class UBlendableInterface> InBlendableObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InWeight (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USceneCaptureComponent2D::AddOrUpdateBlendable(const TScriptInterface<class UBlendableInterface>& InBlendableObject, float InWeight)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponent2D.AddOrUpdateBlendable");
|
|
|
|
USceneCaptureComponent2D_AddOrUpdateBlendable_Params params;
|
|
params.InBlendableObject = InBlendableObject;
|
|
params.InWeight = InWeight;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureComponentCube.CaptureScene
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USceneCaptureComponentCube::CaptureScene()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureComponentCube.CaptureScene");
|
|
|
|
USceneCaptureComponentCube_CaptureScene_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SceneCaptureCube.OnInterpToggle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bEnable (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void ASceneCaptureCube::OnInterpToggle(bool bEnable)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SceneCaptureCube.OnInterpToggle");
|
|
|
|
ASceneCaptureCube_OnInterpToggle_Params params;
|
|
params.bEnable = bEnable;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.NumSockets
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int USkeletalMesh::NumSockets()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.NumSockets");
|
|
|
|
USkeletalMesh_NumSockets_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.IsSectionUsingCloth
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int InSectionIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bCheckCorrespondingSections (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USkeletalMesh::IsSectionUsingCloth(int InSectionIndex, bool bCheckCorrespondingSections)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.IsSectionUsingCloth");
|
|
|
|
USkeletalMesh_IsSectionUsingCloth_Params params;
|
|
params.InSectionIndex = InSectionIndex;
|
|
params.bCheckCorrespondingSections = bCheckCorrespondingSections;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.GetSocketByIndex
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USkeletalMeshSocket* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USkeletalMeshSocket* USkeletalMesh::GetSocketByIndex(int Index)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.GetSocketByIndex");
|
|
|
|
USkeletalMesh_GetSocketByIndex_Params params;
|
|
params.Index = Index;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.GetNodeMappingContainer
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UBlueprint* SourceAsset (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UNodeMappingContainer* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UNodeMappingContainer* USkeletalMesh::GetNodeMappingContainer(class UBlueprint* SourceAsset)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.GetNodeMappingContainer");
|
|
|
|
USkeletalMesh_GetNodeMappingContainer_Params params;
|
|
params.SourceAsset = SourceAsset;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.GetImportedBounds
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBoxSphereBounds ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FBoxSphereBounds USkeletalMesh::GetImportedBounds()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.GetImportedBounds");
|
|
|
|
USkeletalMesh_GetImportedBounds_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.GetBounds
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBoxSphereBounds ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FBoxSphereBounds USkeletalMesh::GetBounds()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.GetBounds");
|
|
|
|
USkeletalMesh_GetBounds_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.FindSocketAndIndex
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int OutIndex (Parm, OutParm, ZeroConstructor, IsPlainOldData)
|
|
// class USkeletalMeshSocket* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USkeletalMeshSocket* USkeletalMesh::FindSocketAndIndex(const struct FName& InSocketName, int* OutIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.FindSocketAndIndex");
|
|
|
|
USkeletalMesh_FindSocketAndIndex_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (OutIndex != nullptr)
|
|
*OutIndex = params.OutIndex;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMesh.FindSocket
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName InSocketName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class USkeletalMeshSocket* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class USkeletalMeshSocket* USkeletalMesh::FindSocket(const struct FName& InSocketName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMesh.FindSocket");
|
|
|
|
USkeletalMesh_FindSocket_Params params;
|
|
params.InSocketName = InSocketName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshActor.OnRep_ReplicatedPhysAsset
|
|
// (Native, Public)
|
|
|
|
void ASkeletalMeshActor::OnRep_ReplicatedPhysAsset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshActor.OnRep_ReplicatedPhysAsset");
|
|
|
|
ASkeletalMeshActor_OnRep_ReplicatedPhysAsset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshActor.OnRep_ReplicatedMesh
|
|
// (Native, Public)
|
|
|
|
void ASkeletalMeshActor::OnRep_ReplicatedMesh()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshActor.OnRep_ReplicatedMesh");
|
|
|
|
ASkeletalMeshActor_OnRep_ReplicatedMesh_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshActor.OnRep_ReplicatedMaterial1
|
|
// (Native, Public)
|
|
|
|
void ASkeletalMeshActor::OnRep_ReplicatedMaterial1()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshActor.OnRep_ReplicatedMaterial1");
|
|
|
|
ASkeletalMeshActor_OnRep_ReplicatedMaterial1_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshActor.OnRep_ReplicatedMaterial0
|
|
// (Native, Public)
|
|
|
|
void ASkeletalMeshActor::OnRep_ReplicatedMaterial0()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshActor.OnRep_ReplicatedMaterial0");
|
|
|
|
ASkeletalMeshActor_OnRep_ReplicatedMaterial0_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshSocket.InitializeSocketFromLocation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* SkelComp (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FVector WorldLocation (Parm, IsPlainOldData)
|
|
// struct FVector WorldNormal (Parm, IsPlainOldData)
|
|
|
|
void USkeletalMeshSocket::InitializeSocketFromLocation(class USkeletalMeshComponent* SkelComp, const struct FVector& WorldLocation, const struct FVector& WorldNormal)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshSocket.InitializeSocketFromLocation");
|
|
|
|
USkeletalMeshSocket_InitializeSocketFromLocation_Params params;
|
|
params.SkelComp = SkelComp;
|
|
params.WorldLocation = WorldLocation;
|
|
params.WorldNormal = WorldNormal;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkeletalMeshSocket.GetSocketLocation
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* SkelComp (ConstParm, Parm, ZeroConstructor, InstancedReference, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USkeletalMeshSocket::GetSocketLocation(class USkeletalMeshComponent* SkelComp)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkeletalMeshSocket.GetSocketLocation");
|
|
|
|
USkeletalMeshSocket_GetSocketLocation_Params params;
|
|
params.SkelComp = SkelComp;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLight.OnRep_bEnabled
|
|
// (Native, Public)
|
|
|
|
void ASkyLight::OnRep_bEnabled()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLight.OnRep_bEnabled");
|
|
|
|
ASkyLight_OnRep_bEnabled_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetVolumetricScatteringIntensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetVolumetricScatteringIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetVolumetricScatteringIntensity");
|
|
|
|
USkyLightComponent_SetVolumetricScatteringIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetOcclusionTint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FColor InTint (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetOcclusionTint(const struct FColor& InTint)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetOcclusionTint");
|
|
|
|
USkyLightComponent_SetOcclusionTint_Params params;
|
|
params.InTint = InTint;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetOcclusionExponent
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOcclusionExponent (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetOcclusionExponent(float InOcclusionExponent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetOcclusionExponent");
|
|
|
|
USkyLightComponent_SetOcclusionExponent_Params params;
|
|
params.InOcclusionExponent = InOcclusionExponent;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetOcclusionContrast
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InOcclusionContrast (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetOcclusionContrast(float InOcclusionContrast)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetOcclusionContrast");
|
|
|
|
USkyLightComponent_SetOcclusionContrast_Params params;
|
|
params.InOcclusionContrast = InOcclusionContrast;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetMinOcclusion
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InMinOcclusion (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetMinOcclusion(float InMinOcclusion)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetMinOcclusion");
|
|
|
|
USkyLightComponent_SetMinOcclusion_Params params;
|
|
params.InMinOcclusion = InMinOcclusion;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetLightColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor NewLightColor (Parm, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetLightColor(const struct FLinearColor& NewLightColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetLightColor");
|
|
|
|
USkyLightComponent_SetLightColor_Params params;
|
|
params.NewLightColor = NewLightColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetIntensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetIntensity");
|
|
|
|
USkyLightComponent_SetIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetIndirectLightingIntensity
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetIndirectLightingIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetIndirectLightingIntensity");
|
|
|
|
USkyLightComponent_SetIndirectLightingIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetCubemapBlend
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTextureCube* SourceCubemap (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UTextureCube* DestinationCubemap (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float InBlendFraction (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetCubemapBlend(class UTextureCube* SourceCubemap, class UTextureCube* DestinationCubemap, float InBlendFraction)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetCubemapBlend");
|
|
|
|
USkyLightComponent_SetCubemapBlend_Params params;
|
|
params.SourceCubemap = SourceCubemap;
|
|
params.DestinationCubemap = DestinationCubemap;
|
|
params.InBlendFraction = InBlendFraction;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.SetCubemap
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTextureCube* NewCubemap (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USkyLightComponent::SetCubemap(class UTextureCube* NewCubemap)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.SetCubemap");
|
|
|
|
USkyLightComponent_SetCubemap_Params params;
|
|
params.NewCubemap = NewCubemap;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SkyLightComponent.RecaptureSky
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USkyLightComponent::RecaptureSky()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SkyLightComponent.RecaptureSky");
|
|
|
|
USkyLightComponent_RecaptureSky_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.UpdateSpline
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USplineComponent::UpdateSpline()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.UpdateSpline");
|
|
|
|
USplineComponent_UpdateSpline_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetWorldLocationAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void USplineComponent::SetWorldLocationAtSplinePoint(int PointIndex, const struct FVector& InLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetWorldLocationAtSplinePoint");
|
|
|
|
USplineComponent_SetWorldLocationAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.InLocation = InLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetUpVectorAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InUpVector (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetUpVectorAtSplinePoint(int PointIndex, const struct FVector& InUpVector, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetUpVectorAtSplinePoint");
|
|
|
|
USplineComponent_SetUpVectorAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.InUpVector = InUpVector;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetUnselectedSplineSegmentColor
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor SegmentColor (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void USplineComponent::SetUnselectedSplineSegmentColor(const struct FLinearColor& SegmentColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetUnselectedSplineSegmentColor");
|
|
|
|
USplineComponent_SetUnselectedSplineSegmentColor_Params params;
|
|
params.SegmentColor = SegmentColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetTangentsAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InArriveTangent (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector InLeaveTangent (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetTangentsAtSplinePoint(int PointIndex, const struct FVector& InArriveTangent, const struct FVector& InLeaveTangent, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetTangentsAtSplinePoint");
|
|
|
|
USplineComponent_SetTangentsAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.InArriveTangent = InArriveTangent;
|
|
params.InLeaveTangent = InLeaveTangent;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetTangentAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InTangent (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetTangentAtSplinePoint(int PointIndex, const struct FVector& InTangent, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetTangentAtSplinePoint");
|
|
|
|
USplineComponent_SetTangentAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.InTangent = InTangent;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetSplineWorldPoints
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FVector> Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void USplineComponent::SetSplineWorldPoints(TArray<struct FVector> Points)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetSplineWorldPoints");
|
|
|
|
USplineComponent_SetSplineWorldPoints_Params params;
|
|
params.Points = Points;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetSplinePointType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplinePointType> Type (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetSplinePointType(int PointIndex, TEnumAsByte<ESplinePointType> Type, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetSplinePointType");
|
|
|
|
USplineComponent_SetSplinePointType_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.Type = Type;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetSplinePoints
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FVector> Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetSplinePoints(TArray<struct FVector> Points, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetSplinePoints");
|
|
|
|
USplineComponent_SetSplinePoints_Params params;
|
|
params.Points = Points;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetSplineLocalPoints
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FVector> Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
|
|
void USplineComponent::SetSplineLocalPoints(TArray<struct FVector> Points)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetSplineLocalPoints");
|
|
|
|
USplineComponent_SetSplineLocalPoints_Params params;
|
|
params.Points = Points;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetSelectedSplineSegmentColor
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FLinearColor SegmentColor (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void USplineComponent::SetSelectedSplineSegmentColor(const struct FLinearColor& SegmentColor)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetSelectedSplineSegmentColor");
|
|
|
|
USplineComponent_SetSelectedSplineSegmentColor_Params params;
|
|
params.SegmentColor = SegmentColor;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetLocationAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector InLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetLocationAtSplinePoint(int PointIndex, const struct FVector& InLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetLocationAtSplinePoint");
|
|
|
|
USplineComponent_SetLocationAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.InLocation = InLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetDrawDebug
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bShow (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetDrawDebug(bool bShow)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetDrawDebug");
|
|
|
|
USplineComponent_SetDrawDebug_Params params;
|
|
params.bShow = bShow;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetDefaultUpVector
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector UpVector (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetDefaultUpVector(const struct FVector& UpVector, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetDefaultUpVector");
|
|
|
|
USplineComponent_SetDefaultUpVector_Params params;
|
|
params.UpVector = UpVector;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetClosedLoopAtPosition
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInClosedLoop (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float Key (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetClosedLoopAtPosition(bool bInClosedLoop, float Key, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetClosedLoopAtPosition");
|
|
|
|
USplineComponent_SetClosedLoopAtPosition_Params params;
|
|
params.bInClosedLoop = bInClosedLoop;
|
|
params.Key = Key;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.SetClosedLoop
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bInClosedLoop (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::SetClosedLoop(bool bInClosedLoop, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.SetClosedLoop");
|
|
|
|
USplineComponent_SetClosedLoop_Params params;
|
|
params.bInClosedLoop = bInClosedLoop;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.RemoveSplinePoint
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::RemoveSplinePoint(int Index, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.RemoveSplinePoint");
|
|
|
|
USplineComponent_RemoveSplinePoint_Params params;
|
|
params.Index = Index;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.IsClosedLoop
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool USplineComponent::IsClosedLoop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.IsClosedLoop");
|
|
|
|
USplineComponent_IsClosedLoop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldTangentAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetWorldTangentAtDistanceAlongSpline(float Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldTangentAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetWorldTangentAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldRotationAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USplineComponent::GetWorldRotationAtTime(float Time, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldRotationAtTime");
|
|
|
|
USplineComponent_GetWorldRotationAtTime_Params params;
|
|
params.Time = Time;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldRotationAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USplineComponent::GetWorldRotationAtDistanceAlongSpline(float Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldRotationAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetWorldRotationAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldLocationAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetWorldLocationAtTime(float Time, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldLocationAtTime");
|
|
|
|
USplineComponent_GetWorldLocationAtTime_Params params;
|
|
params.Time = Time;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldLocationAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetWorldLocationAtSplinePoint(int PointIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldLocationAtSplinePoint");
|
|
|
|
USplineComponent_GetWorldLocationAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldLocationAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetWorldLocationAtDistanceAlongSpline(float Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldLocationAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetWorldLocationAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldDirectionAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetWorldDirectionAtTime(float Time, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldDirectionAtTime");
|
|
|
|
USplineComponent_GetWorldDirectionAtTime_Params params;
|
|
params.Time = Time;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetWorldDirectionAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetWorldDirectionAtDistanceAlongSpline(float Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetWorldDirectionAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetWorldDirectionAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetUpVectorAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetUpVectorAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetUpVectorAtTime");
|
|
|
|
USplineComponent_GetUpVectorAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetUpVectorAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetUpVectorAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetUpVectorAtSplinePoint");
|
|
|
|
USplineComponent_GetUpVectorAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetUpVectorAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetUpVectorAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetUpVectorAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetUpVectorAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetTransformAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USplineComponent::GetTransformAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity, bool bUseScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetTransformAtTime");
|
|
|
|
USplineComponent_GetTransformAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
params.bUseScale = bUseScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetTransformAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USplineComponent::GetTransformAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetTransformAtSplinePoint");
|
|
|
|
USplineComponent_GetTransformAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseScale = bUseScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetTransformAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USplineComponent::GetTransformAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetTransformAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetTransformAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseScale = bUseScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetTangentAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetTangentAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetTangentAtTime");
|
|
|
|
USplineComponent_GetTangentAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetTangentAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetTangentAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetTangentAtSplinePoint");
|
|
|
|
USplineComponent_GetTangentAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetTangentAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetTangentAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetTangentAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetTangentAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetSplinePointType
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplinePointType> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ESplinePointType> USplineComponent::GetSplinePointType(int PointIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetSplinePointType");
|
|
|
|
USplineComponent_GetSplinePointType_Params params;
|
|
params.PointIndex = PointIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetSplineLength
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::GetSplineLength()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetSplineLength");
|
|
|
|
USplineComponent_GetSplineLength_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetScaleAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetScaleAtTime(float Time, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetScaleAtTime");
|
|
|
|
USplineComponent_GetScaleAtTime_Params params;
|
|
params.Time = Time;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetScaleAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetScaleAtSplinePoint(int PointIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetScaleAtSplinePoint");
|
|
|
|
USplineComponent_GetScaleAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetScaleAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetScaleAtDistanceAlongSpline(float Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetScaleAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetScaleAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRotationAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USplineComponent::GetRotationAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRotationAtTime");
|
|
|
|
USplineComponent_GetRotationAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRotationAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USplineComponent::GetRotationAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRotationAtSplinePoint");
|
|
|
|
USplineComponent_GetRotationAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRotationAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USplineComponent::GetRotationAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRotationAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetRotationAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRollAtTime
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::GetRollAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRollAtTime");
|
|
|
|
USplineComponent_GetRollAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRollAtSplinePoint
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::GetRollAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRollAtSplinePoint");
|
|
|
|
USplineComponent_GetRollAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRollAtDistanceAlongSpline
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::GetRollAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRollAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetRollAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRightVectorAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetRightVectorAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRightVectorAtTime");
|
|
|
|
USplineComponent_GetRightVectorAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRightVectorAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetRightVectorAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRightVectorAtSplinePoint");
|
|
|
|
USplineComponent_GetRightVectorAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetRightVectorAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetRightVectorAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetRightVectorAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetRightVectorAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetNumberOfSplinePoints
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int USplineComponent::GetNumberOfSplinePoints()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetNumberOfSplinePoints");
|
|
|
|
USplineComponent_GetNumberOfSplinePoints_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetLocationAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetLocationAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetLocationAtTime");
|
|
|
|
USplineComponent_GetLocationAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetLocationAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetLocationAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetLocationAtSplinePoint");
|
|
|
|
USplineComponent_GetLocationAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetLocationAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetLocationAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetLocationAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetLocationAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetLocationAndTangentAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector Tangent (Parm, OutParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::GetLocationAndTangentAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, struct FVector* Location, struct FVector* Tangent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetLocationAndTangentAtSplinePoint");
|
|
|
|
USplineComponent_GetLocationAndTangentAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (Location != nullptr)
|
|
*Location = params.Location;
|
|
if (Tangent != nullptr)
|
|
*Tangent = params.Tangent;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetLocalLocationAndTangentAtSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector LocalLocation (Parm, OutParm, IsPlainOldData)
|
|
// struct FVector LocalTangent (Parm, OutParm, IsPlainOldData)
|
|
|
|
void USplineComponent::GetLocalLocationAndTangentAtSplinePoint(int PointIndex, struct FVector* LocalLocation, struct FVector* LocalTangent)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetLocalLocationAndTangentAtSplinePoint");
|
|
|
|
USplineComponent_GetLocalLocationAndTangentAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
if (LocalLocation != nullptr)
|
|
*LocalLocation = params.LocalLocation;
|
|
if (LocalTangent != nullptr)
|
|
*LocalTangent = params.LocalTangent;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetLeaveTangentAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetLeaveTangentAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetLeaveTangentAtSplinePoint");
|
|
|
|
USplineComponent_GetLeaveTangentAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetInputKeyAtDistanceAlongSpline
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::GetInputKeyAtDistanceAlongSpline(float Distance)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetInputKeyAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetInputKeyAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetDistanceAlongSplineAtSplinePoint
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::GetDistanceAlongSplineAtSplinePoint(int PointIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetDistanceAlongSplineAtSplinePoint");
|
|
|
|
USplineComponent_GetDistanceAlongSplineAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetDirectionAtTime
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseConstantVelocity (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetDirectionAtTime(float Time, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseConstantVelocity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetDirectionAtTime");
|
|
|
|
USplineComponent_GetDirectionAtTime_Params params;
|
|
params.Time = Time;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseConstantVelocity = bUseConstantVelocity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetDirectionAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetDirectionAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetDirectionAtSplinePoint");
|
|
|
|
USplineComponent_GetDirectionAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetDirectionAtDistanceAlongSpline
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float Distance (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetDirectionAtDistanceAlongSpline(float Distance, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetDirectionAtDistanceAlongSpline");
|
|
|
|
USplineComponent_GetDirectionAtDistanceAlongSpline_Params params;
|
|
params.Distance = Distance;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetDefaultUpVector
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetDefaultUpVector(TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetDefaultUpVector");
|
|
|
|
USplineComponent_GetDefaultUpVector_Params params;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.GetArriveTangentAtSplinePoint
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int PointIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::GetArriveTangentAtSplinePoint(int PointIndex, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.GetArriveTangentAtSplinePoint");
|
|
|
|
USplineComponent_GetArriveTangentAtSplinePoint_Params params;
|
|
params.PointIndex = PointIndex;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindUpVectorClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::FindUpVectorClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindUpVectorClosestToWorldLocation");
|
|
|
|
USplineComponent_FindUpVectorClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindTransformClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUseScale (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FTransform USplineComponent::FindTransformClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUseScale)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindTransformClosestToWorldLocation");
|
|
|
|
USplineComponent_FindTransformClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUseScale = bUseScale;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindTangentClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::FindTangentClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindTangentClosestToWorldLocation");
|
|
|
|
USplineComponent_FindTangentClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindScaleClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::FindScaleClosestToWorldLocation(const struct FVector& WorldLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindScaleClosestToWorldLocation");
|
|
|
|
USplineComponent_FindScaleClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindRotationClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FRotator ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FRotator USplineComponent::FindRotationClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindRotationClosestToWorldLocation");
|
|
|
|
USplineComponent_FindRotationClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindRollClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::FindRollClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindRollClosestToWorldLocation");
|
|
|
|
USplineComponent_FindRollClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindRightVectorClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::FindRightVectorClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindRightVectorClosestToWorldLocation");
|
|
|
|
USplineComponent_FindRightVectorClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindLocationClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::FindLocationClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindLocationClosestToWorldLocation");
|
|
|
|
USplineComponent_FindLocationClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindInputKeyClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineComponent::FindInputKeyClosestToWorldLocation(const struct FVector& WorldLocation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindInputKeyClosestToWorldLocation");
|
|
|
|
USplineComponent_FindInputKeyClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.FindDirectionClosestToWorldLocation
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector WorldLocation (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineComponent::FindDirectionClosestToWorldLocation(const struct FVector& WorldLocation, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.FindDirectionClosestToWorldLocation");
|
|
|
|
USplineComponent_FindDirectionClosestToWorldLocation_Params params;
|
|
params.WorldLocation = WorldLocation;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.ClearSplinePoints
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::ClearSplinePoints(bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.ClearSplinePoints");
|
|
|
|
USplineComponent_ClearSplinePoints_Params params;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.AddSplineWorldPoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Position (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void USplineComponent::AddSplineWorldPoint(const struct FVector& Position)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.AddSplineWorldPoint");
|
|
|
|
USplineComponent_AddSplineWorldPoint_Params params;
|
|
params.Position = Position;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.AddSplinePointAtIndex
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Position (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// int Index (Parm, ZeroConstructor, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::AddSplinePointAtIndex(const struct FVector& Position, int Index, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.AddSplinePointAtIndex");
|
|
|
|
USplineComponent_AddSplinePointAtIndex_Params params;
|
|
params.Position = Position;
|
|
params.Index = Index;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.AddSplinePoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Position (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::AddSplinePoint(const struct FVector& Position, TEnumAsByte<ESplineCoordinateSpace> CoordinateSpace, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.AddSplinePoint");
|
|
|
|
USplineComponent_AddSplinePoint_Params params;
|
|
params.Position = Position;
|
|
params.CoordinateSpace = CoordinateSpace;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.AddSplineLocalPoint
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector Position (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
|
|
void USplineComponent::AddSplineLocalPoint(const struct FVector& Position)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.AddSplineLocalPoint");
|
|
|
|
USplineComponent_AddSplineLocalPoint_Params params;
|
|
params.Position = Position;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.AddPoints
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// TArray<struct FSplinePoint> Points (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::AddPoints(TArray<struct FSplinePoint> Points, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.AddPoints");
|
|
|
|
USplineComponent_AddPoints_Params params;
|
|
params.Points = Points;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineComponent.AddPoint
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSplinePoint Point (ConstParm, Parm, OutParm, ReferenceParm)
|
|
// bool bUpdateSpline (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineComponent::AddPoint(const struct FSplinePoint& Point, bool bUpdateSpline)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineComponent.AddPoint");
|
|
|
|
USplineComponent_AddPoint_Params params;
|
|
params.Point = Point;
|
|
params.bUpdateSpline = bUpdateSpline;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.UpdateMesh
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void USplineMeshComponent::UpdateMesh()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.UpdateMesh");
|
|
|
|
USplineMeshComponent_UpdateMesh_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetStartTangent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector StartTangent (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetStartTangent(const struct FVector& StartTangent, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetStartTangent");
|
|
|
|
USplineMeshComponent_SetStartTangent_Params params;
|
|
params.StartTangent = StartTangent;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetStartScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D StartScale (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetStartScale(const struct FVector2D& StartScale, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetStartScale");
|
|
|
|
USplineMeshComponent_SetStartScale_Params params;
|
|
params.StartScale = StartScale;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetStartRoll
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float StartRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetStartRoll(float StartRoll, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetStartRoll");
|
|
|
|
USplineMeshComponent_SetStartRoll_Params params;
|
|
params.StartRoll = StartRoll;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetStartPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector startPos (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetStartPosition(const struct FVector& startPos, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetStartPosition");
|
|
|
|
USplineMeshComponent_SetStartPosition_Params params;
|
|
params.startPos = startPos;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetStartOffset
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D StartOffset (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetStartOffset(const struct FVector2D& StartOffset, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetStartOffset");
|
|
|
|
USplineMeshComponent_SetStartOffset_Params params;
|
|
params.StartOffset = StartOffset;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetStartAndEnd
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector startPos (Parm, IsPlainOldData)
|
|
// struct FVector StartTangent (Parm, IsPlainOldData)
|
|
// struct FVector EndPos (Parm, IsPlainOldData)
|
|
// struct FVector EndTangent (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetStartAndEnd(const struct FVector& startPos, const struct FVector& StartTangent, const struct FVector& EndPos, const struct FVector& EndTangent, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetStartAndEnd");
|
|
|
|
USplineMeshComponent_SetStartAndEnd_Params params;
|
|
params.startPos = startPos;
|
|
params.StartTangent = StartTangent;
|
|
params.EndPos = EndPos;
|
|
params.EndTangent = EndTangent;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetSplineUpDir
|
|
// (Final, Native, Public, HasOutParms, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector InSplineUpDir (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetSplineUpDir(const struct FVector& InSplineUpDir, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetSplineUpDir");
|
|
|
|
USplineMeshComponent_SetSplineUpDir_Params params;
|
|
params.InSplineUpDir = InSplineUpDir;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetForwardAxis
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ESplineMeshAxis> InForwardAxis (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetForwardAxis(TEnumAsByte<ESplineMeshAxis> InForwardAxis, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetForwardAxis");
|
|
|
|
USplineMeshComponent_SetForwardAxis_Params params;
|
|
params.InForwardAxis = InForwardAxis;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetEndTangent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector EndTangent (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetEndTangent(const struct FVector& EndTangent, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetEndTangent");
|
|
|
|
USplineMeshComponent_SetEndTangent_Params params;
|
|
params.EndTangent = EndTangent;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetEndScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D EndScale (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetEndScale(const struct FVector2D& EndScale, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetEndScale");
|
|
|
|
USplineMeshComponent_SetEndScale_Params params;
|
|
params.EndScale = EndScale;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetEndRoll
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float EndRoll (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetEndRoll(float EndRoll, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetEndRoll");
|
|
|
|
USplineMeshComponent_SetEndRoll_Params params;
|
|
params.EndRoll = EndRoll;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetEndPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector EndPos (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetEndPosition(const struct FVector& EndPos, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetEndPosition");
|
|
|
|
USplineMeshComponent_SetEndPosition_Params params;
|
|
params.EndPos = EndPos;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetEndOffset
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D EndOffset (Parm, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetEndOffset(const struct FVector2D& EndOffset, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetEndOffset");
|
|
|
|
USplineMeshComponent_SetEndOffset_Params params;
|
|
params.EndOffset = EndOffset;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetBoundaryMin
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InBoundaryMin (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetBoundaryMin(float InBoundaryMin, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetBoundaryMin");
|
|
|
|
USplineMeshComponent_SetBoundaryMin_Params params;
|
|
params.InBoundaryMin = InBoundaryMin;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.SetBoundaryMax
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InBoundaryMax (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bUpdateMesh (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USplineMeshComponent::SetBoundaryMax(float InBoundaryMax, bool bUpdateMesh)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.SetBoundaryMax");
|
|
|
|
USplineMeshComponent_SetBoundaryMax_Params params;
|
|
params.InBoundaryMax = InBoundaryMax;
|
|
params.bUpdateMesh = bUpdateMesh;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetStartTangent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineMeshComponent::GetStartTangent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetStartTangent");
|
|
|
|
USplineMeshComponent_GetStartTangent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetStartScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USplineMeshComponent::GetStartScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetStartScale");
|
|
|
|
USplineMeshComponent_GetStartScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetStartRoll
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineMeshComponent::GetStartRoll()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetStartRoll");
|
|
|
|
USplineMeshComponent_GetStartRoll_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetStartPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineMeshComponent::GetStartPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetStartPosition");
|
|
|
|
USplineMeshComponent_GetStartPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetStartOffset
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USplineMeshComponent::GetStartOffset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetStartOffset");
|
|
|
|
USplineMeshComponent_GetStartOffset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetSplineUpDir
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineMeshComponent::GetSplineUpDir()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetSplineUpDir");
|
|
|
|
USplineMeshComponent_GetSplineUpDir_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetForwardAxis
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// TEnumAsByte<ESplineMeshAxis> ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
TEnumAsByte<ESplineMeshAxis> USplineMeshComponent::GetForwardAxis()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetForwardAxis");
|
|
|
|
USplineMeshComponent_GetForwardAxis_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetEndTangent
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineMeshComponent::GetEndTangent()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetEndTangent");
|
|
|
|
USplineMeshComponent_GetEndTangent_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetEndScale
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USplineMeshComponent::GetEndScale()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetEndScale");
|
|
|
|
USplineMeshComponent_GetEndScale_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetEndRoll
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineMeshComponent::GetEndRoll()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetEndRoll");
|
|
|
|
USplineMeshComponent_GetEndRoll_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetEndPosition
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector USplineMeshComponent::GetEndPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetEndPosition");
|
|
|
|
USplineMeshComponent_GetEndPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetEndOffset
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D USplineMeshComponent::GetEndOffset()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetEndOffset");
|
|
|
|
USplineMeshComponent_GetEndOffset_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetBoundaryMin
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineMeshComponent::GetBoundaryMin()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetBoundaryMin");
|
|
|
|
USplineMeshComponent_GetBoundaryMin_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SplineMeshComponent.GetBoundaryMax
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float USplineMeshComponent::GetBoundaryMax()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SplineMeshComponent.GetBoundaryMax");
|
|
|
|
USplineMeshComponent_GetBoundaryMax_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.SpotLightComponent.SetOuterConeAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewOuterConeAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpotLightComponent::SetOuterConeAngle(float NewOuterConeAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SpotLightComponent.SetOuterConeAngle");
|
|
|
|
USpotLightComponent_SetOuterConeAngle_Params params;
|
|
params.NewOuterConeAngle = NewOuterConeAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.SpotLightComponent.SetInnerConeAngle
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewInnerConeAngle (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void USpotLightComponent::SetInnerConeAngle(float NewInnerConeAngle)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.SpotLightComponent.SetInnerConeAngle");
|
|
|
|
USpotLightComponent_SetInnerConeAngle_Params params;
|
|
params.NewInnerConeAngle = NewInnerConeAngle;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMesh.GetNumSections
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int InLOD (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UStaticMesh::GetNumSections(int InLOD)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMesh.GetNumSections");
|
|
|
|
UStaticMesh_GetNumSections_Params params;
|
|
params.InLOD = InLOD;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMesh.GetNumLODs
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UStaticMesh::GetNumLODs()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMesh.GetNumLODs");
|
|
|
|
UStaticMesh_GetNumLODs_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMesh.GetMaterialIndex
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FName MaterialSlotName (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UStaticMesh::GetMaterialIndex(const struct FName& MaterialSlotName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMesh.GetMaterialIndex");
|
|
|
|
UStaticMesh_GetMaterialIndex_Params params;
|
|
params.MaterialSlotName = MaterialSlotName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMesh.GetMaterial
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int MaterialIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// class UMaterialInterface* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UMaterialInterface* UStaticMesh::GetMaterial(int MaterialIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMesh.GetMaterial");
|
|
|
|
UStaticMesh_GetMaterial_Params params;
|
|
params.MaterialIndex = MaterialIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMesh.GetBounds
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FBoxSphereBounds ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FBoxSphereBounds UStaticMesh::GetBounds()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMesh.GetBounds");
|
|
|
|
UStaticMesh_GetBounds_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StaticMesh.GetBoundingBox
|
|
// (Final, RequiredAPI, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FBox ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FBox UStaticMesh::GetBoundingBox()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StaticMesh.GetBoundingBox");
|
|
|
|
UStaticMesh_GetBoundingBox_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.SetUVRect
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBox2D InUVRect (Parm)
|
|
|
|
void UStereoLayerComponent::SetUVRect(const struct FBox2D& InUVRect)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.SetUVRect");
|
|
|
|
UStereoLayerComponent_SetUVRect_Params params;
|
|
params.InUVRect = InUVRect;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.SetTexture
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* InTexture (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStereoLayerComponent::SetTexture(class UTexture* InTexture)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.SetTexture");
|
|
|
|
UStereoLayerComponent_SetTexture_Params params;
|
|
params.InTexture = InTexture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.SetQuadSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FVector2D InQuadSize (Parm, IsPlainOldData)
|
|
|
|
void UStereoLayerComponent::SetQuadSize(const struct FVector2D& InQuadSize)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.SetQuadSize");
|
|
|
|
UStereoLayerComponent_SetQuadSize_Params params;
|
|
params.InQuadSize = InQuadSize;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.SetPriority
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// int InPriority (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStereoLayerComponent::SetPriority(int InPriority)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.SetPriority");
|
|
|
|
UStereoLayerComponent_SetPriority_Params params;
|
|
params.InPriority = InPriority;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.MarkTextureForUpdate
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
|
|
void UStereoLayerComponent::MarkTextureForUpdate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.MarkTextureForUpdate");
|
|
|
|
UStereoLayerComponent_MarkTextureForUpdate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.GetUVRect
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FBox2D ReturnValue (Parm, OutParm, ReturnParm)
|
|
|
|
struct FBox2D UStereoLayerComponent::GetUVRect()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.GetUVRect");
|
|
|
|
UStereoLayerComponent_GetUVRect_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.GetTexture
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// class UTexture* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
class UTexture* UStereoLayerComponent::GetTexture()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.GetTexture");
|
|
|
|
UStereoLayerComponent_GetTexture_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.GetQuadSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector2D ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector2D UStereoLayerComponent::GetQuadSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.GetQuadSize");
|
|
|
|
UStereoLayerComponent_GetQuadSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerComponent.GetPriority
|
|
// (Final, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UStereoLayerComponent::GetPriority()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerComponent.GetPriority");
|
|
|
|
UStereoLayerComponent_GetPriority_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerFunctionLibrary.ShowSplashScreen
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UStereoLayerFunctionLibrary::ShowSplashScreen()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerFunctionLibrary.ShowSplashScreen");
|
|
|
|
UStereoLayerFunctionLibrary_ShowSplashScreen_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerFunctionLibrary.SetSplashScreen
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UTexture* Texture (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector2D Scale (Parm, IsPlainOldData)
|
|
// struct FVector2D Offset (Parm, IsPlainOldData)
|
|
// bool bShowLoadingMovie (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bShowOnSet (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStereoLayerFunctionLibrary::SetSplashScreen(class UTexture* Texture, const struct FVector2D& Scale, const struct FVector2D& Offset, bool bShowLoadingMovie, bool bShowOnSet)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerFunctionLibrary.SetSplashScreen");
|
|
|
|
UStereoLayerFunctionLibrary_SetSplashScreen_Params params;
|
|
params.Texture = Texture;
|
|
params.Scale = Scale;
|
|
params.Offset = Offset;
|
|
params.bShowLoadingMovie = bShowLoadingMovie;
|
|
params.bShowOnSet = bShowOnSet;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerFunctionLibrary.HideSplashScreen
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
|
|
void UStereoLayerFunctionLibrary::HideSplashScreen()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerFunctionLibrary.HideSplashScreen");
|
|
|
|
UStereoLayerFunctionLibrary_HideSplashScreen_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.StereoLayerFunctionLibrary.EnableAutoLoadingSplashScreen
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool InAutoShowEnabled (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UStereoLayerFunctionLibrary::EnableAutoLoadingSplashScreen(bool InAutoShowEnabled)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.StereoLayerFunctionLibrary.EnableAutoLoadingSplashScreen");
|
|
|
|
UStereoLayerFunctionLibrary_EnableAutoLoadingSplashScreen_Params params;
|
|
params.InAutoShowEnabled = InAutoShowEnabled;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetYScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetYScale(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetYScale");
|
|
|
|
UTextRenderComponent_SetYScale_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetXScale
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetXScale(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetXScale");
|
|
|
|
UTextRenderComponent_SetXScale_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetWorldSize
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetWorldSize(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetWorldSize");
|
|
|
|
UTextRenderComponent_SetWorldSize_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetVertSpacingAdjust
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetVertSpacingAdjust(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetVertSpacingAdjust");
|
|
|
|
UTextRenderComponent_SetVertSpacingAdjust_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetVerticalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EVerticalTextAligment> Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetVerticalAlignment(TEnumAsByte<EVerticalTextAligment> Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetVerticalAlignment");
|
|
|
|
UTextRenderComponent_SetVerticalAlignment_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetTextRenderColor
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FColor Value (Parm, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetTextRenderColor(const struct FColor& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetTextRenderColor");
|
|
|
|
UTextRenderComponent_SetTextRenderColor_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetTextMaterial
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UMaterialInterface* Material (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetTextMaterial(class UMaterialInterface* Material)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetTextMaterial");
|
|
|
|
UTextRenderComponent_SetTextMaterial_Params params;
|
|
params.Material = Material;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetText
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FString Value (Parm, ZeroConstructor)
|
|
|
|
void UTextRenderComponent::SetText(const struct FString& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetText");
|
|
|
|
UTextRenderComponent_SetText_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetHorizSpacingAdjust
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetHorizSpacingAdjust(float Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetHorizSpacingAdjust");
|
|
|
|
UTextRenderComponent_SetHorizSpacingAdjust_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetHorizontalAlignment
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<EHorizTextAligment> Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetHorizontalAlignment(TEnumAsByte<EHorizTextAligment> Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetHorizontalAlignment");
|
|
|
|
UTextRenderComponent_SetHorizontalAlignment_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.SetFont
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UFont* Value (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTextRenderComponent::SetFont(class UFont* Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.SetFont");
|
|
|
|
UTextRenderComponent_SetFont_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.K2_SetText
|
|
// (Final, Native, Public, HasOutParms, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FText Value (ConstParm, Parm, OutParm, ReferenceParm)
|
|
|
|
void UTextRenderComponent::K2_SetText(const struct FText& Value)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.K2_SetText");
|
|
|
|
UTextRenderComponent_K2_SetText_Params params;
|
|
params.Value = Value;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.GetTextWorldSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UTextRenderComponent::GetTextWorldSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.GetTextWorldSize");
|
|
|
|
UTextRenderComponent_GetTextWorldSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TextRenderComponent.GetTextLocalSize
|
|
// (Final, Native, Public, HasDefaults, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// struct FVector ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData)
|
|
|
|
struct FVector UTextRenderComponent::GetTextLocalSize()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TextRenderComponent.GetTextLocalSize");
|
|
|
|
UTextRenderComponent_GetTextLocalSize_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.Stop
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
|
|
void UTimelineComponent::Stop()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.Stop");
|
|
|
|
UTimelineComponent_Stop_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetVectorCurve
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCurveVector* NewVectorCurve (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName VectorTrackName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetVectorCurve(class UCurveVector* NewVectorCurve, const struct FName& VectorTrackName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetVectorCurve");
|
|
|
|
UTimelineComponent_SetVectorCurve_Params params;
|
|
params.NewVectorCurve = NewVectorCurve;
|
|
params.VectorTrackName = VectorTrackName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetTimelineLengthMode
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// TEnumAsByte<ETimelineLengthMode> NewLengthMode (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetTimelineLengthMode(TEnumAsByte<ETimelineLengthMode> NewLengthMode)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetTimelineLengthMode");
|
|
|
|
UTimelineComponent_SetTimelineLengthMode_Params params;
|
|
params.NewLengthMode = NewLengthMode;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetTimelineLength
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewLength (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetTimelineLength(float NewLength)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetTimelineLength");
|
|
|
|
UTimelineComponent_SetTimelineLength_Params params;
|
|
params.NewLength = NewLength;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetPlayRate
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewRate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetPlayRate(float NewRate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetPlayRate");
|
|
|
|
UTimelineComponent_SetPlayRate_Params params;
|
|
params.NewRate = NewRate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetPlaybackPosition
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewPosition (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFireEvents (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool bFireUpdate (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetPlaybackPosition(float NewPosition, bool bFireEvents, bool bFireUpdate)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetPlaybackPosition");
|
|
|
|
UTimelineComponent_SetPlaybackPosition_Params params;
|
|
params.NewPosition = NewPosition;
|
|
params.bFireEvents = bFireEvents;
|
|
params.bFireUpdate = bFireUpdate;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetNewTime
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewTime (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetNewTime(float NewTime)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetNewTime");
|
|
|
|
UTimelineComponent_SetNewTime_Params params;
|
|
params.NewTime = NewTime;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetLooping
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewLooping (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetLooping(bool bNewLooping)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetLooping");
|
|
|
|
UTimelineComponent_SetLooping_Params params;
|
|
params.bNewLooping = bNewLooping;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetLinearColorCurve
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCurveLinearColor* NewLinearColorCurve (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName LinearColorTrackName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetLinearColorCurve(class UCurveLinearColor* NewLinearColorCurve, const struct FName& LinearColorTrackName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetLinearColorCurve");
|
|
|
|
UTimelineComponent_SetLinearColorCurve_Params params;
|
|
params.NewLinearColorCurve = NewLinearColorCurve;
|
|
params.LinearColorTrackName = LinearColorTrackName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetIgnoreTimeDilation
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bNewIgnoreTimeDilation (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetIgnoreTimeDilation(bool bNewIgnoreTimeDilation)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetIgnoreTimeDilation");
|
|
|
|
UTimelineComponent_SetIgnoreTimeDilation_Params params;
|
|
params.bNewIgnoreTimeDilation = bNewIgnoreTimeDilation;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.SetFloatCurve
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UCurveFloat* NewFloatCurve (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName FloatTrackName (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UTimelineComponent::SetFloatCurve(class UCurveFloat* NewFloatCurve, const struct FName& FloatTrackName)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.SetFloatCurve");
|
|
|
|
UTimelineComponent_SetFloatCurve_Params params;
|
|
params.NewFloatCurve = NewFloatCurve;
|
|
params.FloatTrackName = FloatTrackName;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.ReverseFromEnd
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
|
|
void UTimelineComponent::ReverseFromEnd()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.ReverseFromEnd");
|
|
|
|
UTimelineComponent_ReverseFromEnd_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.Reverse
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
|
|
void UTimelineComponent::Reverse()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.Reverse");
|
|
|
|
UTimelineComponent_Reverse_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.PlayFromStart
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
|
|
void UTimelineComponent::PlayFromStart()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.PlayFromStart");
|
|
|
|
UTimelineComponent_PlayFromStart_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.Play
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable)
|
|
|
|
void UTimelineComponent::Play()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.Play");
|
|
|
|
UTimelineComponent_Play_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.OnRep_Timeline
|
|
// (Final, Native, Public)
|
|
|
|
void UTimelineComponent::OnRep_Timeline()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.OnRep_Timeline");
|
|
|
|
UTimelineComponent_OnRep_Timeline_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.IsReversing
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTimelineComponent::IsReversing()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.IsReversing");
|
|
|
|
UTimelineComponent_IsReversing_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.IsPlaying
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTimelineComponent::IsPlaying()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.IsPlaying");
|
|
|
|
UTimelineComponent_IsPlaying_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.IsLooping
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTimelineComponent::IsLooping()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.IsLooping");
|
|
|
|
UTimelineComponent_IsLooping_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.GetTimelineLength
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UTimelineComponent::GetTimelineLength()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.GetTimelineLength");
|
|
|
|
UTimelineComponent_GetTimelineLength_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.GetPlayRate
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UTimelineComponent::GetPlayRate()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.GetPlayRate");
|
|
|
|
UTimelineComponent_GetPlayRate_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.GetPlaybackPosition
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
float UTimelineComponent::GetPlaybackPosition()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.GetPlaybackPosition");
|
|
|
|
UTimelineComponent_GetPlaybackPosition_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TimelineComponent.GetIgnoreTimeDilation
|
|
// (Final, RequiredAPI, Native, Public, BlueprintCallable, BlueprintPure, Const)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTimelineComponent::GetIgnoreTimeDilation()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TimelineComponent.GetIgnoreTimeDilation");
|
|
|
|
UTimelineComponent_GetIgnoreTimeDilation_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.TwitterRequest
|
|
// (Native, Public, HasOutParms)
|
|
// Parameters:
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
// TArray<struct FString> ParamKeysAndValues (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm)
|
|
// TEnumAsByte<ETwitterRequestMethod> RequestMethod (Parm, ZeroConstructor, IsPlainOldData)
|
|
// int AccountIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTwitterIntegrationBase::TwitterRequest(const struct FString& URL, TArray<struct FString> ParamKeysAndValues, TEnumAsByte<ETwitterRequestMethod> RequestMethod, int AccountIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.TwitterRequest");
|
|
|
|
UTwitterIntegrationBase_TwitterRequest_Params params;
|
|
params.URL = URL;
|
|
params.ParamKeysAndValues = ParamKeysAndValues;
|
|
params.RequestMethod = RequestMethod;
|
|
params.AccountIndex = AccountIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.ShowTweetUI
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// struct FString InitialMessage (Parm, ZeroConstructor)
|
|
// struct FString URL (Parm, ZeroConstructor)
|
|
// struct FString Picture (Parm, ZeroConstructor)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTwitterIntegrationBase::ShowTweetUI(const struct FString& InitialMessage, const struct FString& URL, const struct FString& Picture)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.ShowTweetUI");
|
|
|
|
UTwitterIntegrationBase_ShowTweetUI_Params params;
|
|
params.InitialMessage = InitialMessage;
|
|
params.URL = URL;
|
|
params.Picture = Picture;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.Init
|
|
// (Native, Public)
|
|
|
|
void UTwitterIntegrationBase::Init()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.Init");
|
|
|
|
UTwitterIntegrationBase_Init_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.GetNumAccounts
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// int ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
int UTwitterIntegrationBase::GetNumAccounts()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.GetNumAccounts");
|
|
|
|
UTwitterIntegrationBase_GetNumAccounts_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.GetAccountName
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// int AccountIndex (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm)
|
|
|
|
struct FString UTwitterIntegrationBase::GetAccountName(int AccountIndex)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.GetAccountName");
|
|
|
|
UTwitterIntegrationBase_GetAccountName_Params params;
|
|
params.AccountIndex = AccountIndex;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.CanShowTweetUI
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTwitterIntegrationBase::CanShowTweetUI()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.CanShowTweetUI");
|
|
|
|
UTwitterIntegrationBase_CanShowTweetUI_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.TwitterIntegrationBase.AuthorizeAccounts
|
|
// (Native, Public)
|
|
// Parameters:
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData)
|
|
|
|
bool UTwitterIntegrationBase::AuthorizeAccounts()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.TwitterIntegrationBase.AuthorizeAccounts");
|
|
|
|
UTwitterIntegrationBase_AuthorizeAccounts_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
|
|
return params.ReturnValue;
|
|
}
|
|
|
|
|
|
// Function Engine.VectorFieldComponent.SetIntensity
|
|
// (Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float NewIntensity (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UVectorFieldComponent::SetIntensity(float NewIntensity)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.VectorFieldComponent.SetIntensity");
|
|
|
|
UVectorFieldComponent_SetIntensity_Params params;
|
|
params.NewIntensity = NewIntensity;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.VisualLoggerKismetLibrary.LogText
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FString Text (Parm, ZeroConstructor)
|
|
// struct FName LogCategory (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UVisualLoggerKismetLibrary::LogText(class UObject* WorldContextObject, const struct FString& Text, const struct FName& LogCategory)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.VisualLoggerKismetLibrary.LogText");
|
|
|
|
UVisualLoggerKismetLibrary_LogText_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Text = Text;
|
|
params.LogCategory = LogCategory;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.VisualLoggerKismetLibrary.LogLocation
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FVector Location (Parm, IsPlainOldData)
|
|
// struct FString Text (Parm, ZeroConstructor)
|
|
// struct FLinearColor ObjectColor (Parm, IsPlainOldData)
|
|
// float Radius (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FName LogCategory (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UVisualLoggerKismetLibrary::LogLocation(class UObject* WorldContextObject, const struct FVector& Location, const struct FString& Text, const struct FLinearColor& ObjectColor, float Radius, const struct FName& LogCategory)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.VisualLoggerKismetLibrary.LogLocation");
|
|
|
|
UVisualLoggerKismetLibrary_LogLocation_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.Location = Location;
|
|
params.Text = Text;
|
|
params.ObjectColor = ObjectColor;
|
|
params.Radius = Radius;
|
|
params.LogCategory = LogCategory;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.VisualLoggerKismetLibrary.LogBox
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// class UObject* WorldContextObject (Parm, ZeroConstructor, IsPlainOldData)
|
|
// struct FBox BoxShape (Parm, IsPlainOldData)
|
|
// struct FString Text (Parm, ZeroConstructor)
|
|
// struct FLinearColor ObjectColor (Parm, IsPlainOldData)
|
|
// struct FName LogCategory (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UVisualLoggerKismetLibrary::LogBox(class UObject* WorldContextObject, const struct FBox& BoxShape, const struct FString& Text, const struct FLinearColor& ObjectColor, const struct FName& LogCategory)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.VisualLoggerKismetLibrary.LogBox");
|
|
|
|
UVisualLoggerKismetLibrary_LogBox_Params params;
|
|
params.WorldContextObject = WorldContextObject;
|
|
params.BoxShape = BoxShape;
|
|
params.Text = Text;
|
|
params.ObjectColor = ObjectColor;
|
|
params.LogCategory = LogCategory;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
static auto defaultObj = StaticClass()->GetDefaultObject();
|
|
defaultObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WindDirectionalSourceComponent.SetWindType
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// EWindSourceType InNewType (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindDirectionalSourceComponent::SetWindType(EWindSourceType InNewType)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WindDirectionalSourceComponent.SetWindType");
|
|
|
|
UWindDirectionalSourceComponent_SetWindType_Params params;
|
|
params.InNewType = InNewType;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WindDirectionalSourceComponent.SetStrength
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InNewStrength (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindDirectionalSourceComponent::SetStrength(float InNewStrength)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WindDirectionalSourceComponent.SetStrength");
|
|
|
|
UWindDirectionalSourceComponent_SetStrength_Params params;
|
|
params.InNewStrength = InNewStrength;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WindDirectionalSourceComponent.SetSpeed
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InNewSpeed (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindDirectionalSourceComponent::SetSpeed(float InNewSpeed)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WindDirectionalSourceComponent.SetSpeed");
|
|
|
|
UWindDirectionalSourceComponent_SetSpeed_Params params;
|
|
params.InNewSpeed = InNewSpeed;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WindDirectionalSourceComponent.SetRadius
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InNewRadius (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindDirectionalSourceComponent::SetRadius(float InNewRadius)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WindDirectionalSourceComponent.SetRadius");
|
|
|
|
UWindDirectionalSourceComponent_SetRadius_Params params;
|
|
params.InNewRadius = InNewRadius;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WindDirectionalSourceComponent.SetMinimumGustAmount
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InNewMinGust (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindDirectionalSourceComponent::SetMinimumGustAmount(float InNewMinGust)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WindDirectionalSourceComponent.SetMinimumGustAmount");
|
|
|
|
UWindDirectionalSourceComponent_SetMinimumGustAmount_Params params;
|
|
params.InNewMinGust = InNewMinGust;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WindDirectionalSourceComponent.SetMaximumGustAmount
|
|
// (Final, Native, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// float InNewMaxGust (Parm, ZeroConstructor, IsPlainOldData)
|
|
|
|
void UWindDirectionalSourceComponent::SetMaximumGustAmount(float InNewMaxGust)
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WindDirectionalSourceComponent.SetMaximumGustAmount");
|
|
|
|
UWindDirectionalSourceComponent_SetMaximumGustAmount_Params params;
|
|
params.InNewMaxGust = InNewMaxGust;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
// Function Engine.WorldSettings.OnRep_WorldGravityZ
|
|
// (Native, Public)
|
|
|
|
void AWorldSettings::OnRep_WorldGravityZ()
|
|
{
|
|
static UFunction *pFunc = 0;
|
|
if (!pFunc)
|
|
pFunc = UObject::FindObject<UFunction>("Function Engine.WorldSettings.OnRep_WorldGravityZ");
|
|
|
|
AWorldSettings_OnRep_WorldGravityZ_Params params;
|
|
|
|
auto flags = pFunc->FunctionFlags;
|
|
pFunc->FunctionFlags |= 0x400;
|
|
|
|
UObject *currentObj = (UObject *) this;
|
|
currentObj->ProcessEvent(pFunc, ¶ms);
|
|
|
|
pFunc->FunctionFlags = flags;
|
|
}
|
|
|
|
|
|
}
|
|
|