mirror of
https://github.com/swordbluesword/PalWorld-NetCrack.git
synced 2025-04-28 18:37:16 +09:00
9a743d2b16
- Adjusted SDK UGameViewportClient class members and padding - Created helper function to get local player - precompile headers for SDK - SDK made into a static library ( single compile as its never changed )
3111 lines
126 KiB
C++
3111 lines
126 KiB
C++
#pragma once
|
|
|
|
// Dumped with Dumper-7!
|
|
|
|
|
|
#include "../SDK.hpp"
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
// FUNCTIONS
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// Class AnimGraphRuntime.BlendSpacePlayerLibrary
|
|
// (None)
|
|
|
|
class UClass* UBlendSpacePlayerLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("BlendSpacePlayerLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// BlendSpacePlayerLibrary AnimGraphRuntime.Default__BlendSpacePlayerLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UBlendSpacePlayerLibrary* UBlendSpacePlayerLibrary::GetDefaultObj()
|
|
{
|
|
static class UBlendSpacePlayerLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UBlendSpacePlayerLibrary*>(UBlendSpacePlayerLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.ShouldResetPlayTimeWhenBlendSpaceChanges
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UBlendSpacePlayerLibrary::ShouldResetPlayTimeWhenBlendSpaceChanges(struct FBlendSpacePlayerReference& BlendSpacePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "ShouldResetPlayTimeWhenBlendSpaceChanges");
|
|
|
|
Params::UBlendSpacePlayerLibrary_ShouldResetPlayTimeWhenBlendSpaceChanges_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.SetResetPlayTimeWhenBlendSpaceChanges
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool bReset (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FBlendSpacePlayerReference UBlendSpacePlayerLibrary::SetResetPlayTimeWhenBlendSpaceChanges(struct FBlendSpacePlayerReference& BlendSpacePlayer, bool bReset)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "SetResetPlayTimeWhenBlendSpaceChanges");
|
|
|
|
Params::UBlendSpacePlayerLibrary_SetResetPlayTimeWhenBlendSpaceChanges_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
Parms.bReset = bReset;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.SetPlayRate
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float PlayRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FBlendSpacePlayerReference UBlendSpacePlayerLibrary::SetPlayRate(struct FBlendSpacePlayerReference& BlendSpacePlayer, float PlayRate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "SetPlayRate");
|
|
|
|
Params::UBlendSpacePlayerLibrary_SetPlayRate_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
Parms.PlayRate = PlayRate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.SetLoop
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool bLoop (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FBlendSpacePlayerReference UBlendSpacePlayerLibrary::SetLoop(struct FBlendSpacePlayerReference& BlendSpacePlayer, bool bLoop)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "SetLoop");
|
|
|
|
Params::UBlendSpacePlayerLibrary_SetLoop_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
Parms.bLoop = bLoop;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.SetBlendSpaceWithInertialBlending
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UBlendSpace* BlendSpace (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float BlendTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FBlendSpacePlayerReference UBlendSpacePlayerLibrary::SetBlendSpaceWithInertialBlending(struct FAnimUpdateContext& UpdateContext, struct FBlendSpacePlayerReference& BlendSpacePlayer, class UBlendSpace* BlendSpace, float BlendTime)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "SetBlendSpaceWithInertialBlending");
|
|
|
|
Params::UBlendSpacePlayerLibrary_SetBlendSpaceWithInertialBlending_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
Parms.BlendSpace = BlendSpace;
|
|
Parms.BlendTime = BlendTime;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.SetBlendSpace
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UBlendSpace* BlendSpace (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FBlendSpacePlayerReference UBlendSpacePlayerLibrary::SetBlendSpace(struct FBlendSpacePlayerReference& BlendSpacePlayer, class UBlendSpace* BlendSpace)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "SetBlendSpace");
|
|
|
|
Params::UBlendSpacePlayerLibrary_SetBlendSpace_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
Parms.BlendSpace = BlendSpace;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.GetStartPosition
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UBlendSpacePlayerLibrary::GetStartPosition(struct FBlendSpacePlayerReference& BlendSpacePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "GetStartPosition");
|
|
|
|
Params::UBlendSpacePlayerLibrary_GetStartPosition_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.GetPosition
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FVector ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector UBlendSpacePlayerLibrary::GetPosition(struct FBlendSpacePlayerReference& BlendSpacePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "GetPosition");
|
|
|
|
Params::UBlendSpacePlayerLibrary_GetPosition_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.GetPlayRate
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UBlendSpacePlayerLibrary::GetPlayRate(struct FBlendSpacePlayerReference& BlendSpacePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "GetPlayRate");
|
|
|
|
Params::UBlendSpacePlayerLibrary_GetPlayRate_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.GetLoop
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UBlendSpacePlayerLibrary::GetLoop(struct FBlendSpacePlayerReference& BlendSpacePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "GetLoop");
|
|
|
|
Params::UBlendSpacePlayerLibrary_GetLoop_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.GetBlendSpace
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UBlendSpace* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UBlendSpace* UBlendSpacePlayerLibrary::GetBlendSpace(struct FBlendSpacePlayerReference& BlendSpacePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "GetBlendSpace");
|
|
|
|
Params::UBlendSpacePlayerLibrary_GetBlendSpace_Params Parms{};
|
|
|
|
Parms.BlendSpacePlayer = BlendSpacePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.ConvertToBlendSpacePlayerPure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference BlendSpacePlayer (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UBlendSpacePlayerLibrary::ConvertToBlendSpacePlayerPure(struct FAnimNodeReference& Node, struct FBlendSpacePlayerReference* BlendSpacePlayer, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "ConvertToBlendSpacePlayerPure");
|
|
|
|
Params::UBlendSpacePlayerLibrary_ConvertToBlendSpacePlayerPure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (BlendSpacePlayer != nullptr)
|
|
*BlendSpacePlayer = std::move(Parms.BlendSpacePlayer);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.BlendSpacePlayerLibrary.ConvertToBlendSpacePlayer
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBlendSpacePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FBlendSpacePlayerReference UBlendSpacePlayerLibrary::ConvertToBlendSpacePlayer(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("BlendSpacePlayerLibrary", "ConvertToBlendSpacePlayer");
|
|
|
|
Params::UBlendSpacePlayerLibrary_ConvertToBlendSpacePlayer_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.LayeredBoneBlendLibrary
|
|
// (None)
|
|
|
|
class UClass* ULayeredBoneBlendLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LayeredBoneBlendLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LayeredBoneBlendLibrary AnimGraphRuntime.Default__LayeredBoneBlendLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULayeredBoneBlendLibrary* ULayeredBoneBlendLibrary::GetDefaultObj()
|
|
{
|
|
static class ULayeredBoneBlendLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULayeredBoneBlendLibrary*>(ULayeredBoneBlendLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LayeredBoneBlendLibrary.SetBlendMask
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FLayeredBoneBlendReference LayeredBoneBlend (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// int32 PoseIndex (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName BlendMaskName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FLayeredBoneBlendReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FLayeredBoneBlendReference ULayeredBoneBlendLibrary::SetBlendMask(struct FAnimUpdateContext& UpdateContext, struct FLayeredBoneBlendReference& LayeredBoneBlend, int32 PoseIndex, class FName BlendMaskName)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LayeredBoneBlendLibrary", "SetBlendMask");
|
|
|
|
Params::ULayeredBoneBlendLibrary_SetBlendMask_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.LayeredBoneBlend = LayeredBoneBlend;
|
|
Parms.PoseIndex = PoseIndex;
|
|
Parms.BlendMaskName = BlendMaskName;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LayeredBoneBlendLibrary.GetNumPoses
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLayeredBoneBlendReference LayeredBoneBlend (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// int32 ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
int32 ULayeredBoneBlendLibrary::GetNumPoses(struct FLayeredBoneBlendReference& LayeredBoneBlend)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LayeredBoneBlendLibrary", "GetNumPoses");
|
|
|
|
Params::ULayeredBoneBlendLibrary_GetNumPoses_Params Parms{};
|
|
|
|
Parms.LayeredBoneBlend = LayeredBoneBlend;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LayeredBoneBlendLibrary.ConvertToLayeredBoneBlend
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FLayeredBoneBlendReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FLayeredBoneBlendReference ULayeredBoneBlendLibrary::ConvertToLayeredBoneBlend(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LayeredBoneBlendLibrary", "ConvertToLayeredBoneBlend");
|
|
|
|
Params::ULayeredBoneBlendLibrary_ConvertToLayeredBoneBlend_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LayeredBoneBlendLibrary.ConvertToLayeredBlendPerBonePure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FLayeredBoneBlendReference LayeredBoneBlend (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULayeredBoneBlendLibrary::ConvertToLayeredBlendPerBonePure(struct FAnimNodeReference& Node, struct FLayeredBoneBlendReference* LayeredBoneBlend, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LayeredBoneBlendLibrary", "ConvertToLayeredBlendPerBonePure");
|
|
|
|
Params::ULayeredBoneBlendLibrary_ConvertToLayeredBlendPerBonePure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (LayeredBoneBlend != nullptr)
|
|
*LayeredBoneBlend = std::move(Parms.LayeredBoneBlend);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.AnimationStateMachineLibrary
|
|
// (None)
|
|
|
|
class UClass* UAnimationStateMachineLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AnimationStateMachineLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AnimationStateMachineLibrary AnimGraphRuntime.Default__AnimationStateMachineLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAnimationStateMachineLibrary* UAnimationStateMachineLibrary::GetDefaultObj()
|
|
{
|
|
static class UAnimationStateMachineLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAnimationStateMachineLibrary*>(UAnimationStateMachineLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.SetState
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateMachineReferenceNode (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class FName TargetState (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class ETransitionLogicType BlendType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UBlendProfile* BlendProfile (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EAlphaBlendOption AlphaBlendOption (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UCurveFloat* CustomBlendCurve (Parm, ZeroConstructor, NoDestructor, AdvancedDisplay, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAnimationStateMachineLibrary::SetState(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateMachineReference& Node, class FName TargetState, float Duration, enum class ETransitionLogicType BlendType, class UBlendProfile* BlendProfile, enum class EAlphaBlendOption AlphaBlendOption, class UCurveFloat* CustomBlendCurve)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "SetState");
|
|
|
|
Params::UAnimationStateMachineLibrary_SetState_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.Node = Node;
|
|
Parms.TargetState = TargetState;
|
|
Parms.Duration = Duration;
|
|
Parms.BlendType = BlendType;
|
|
Parms.BlendProfile = BlendProfile;
|
|
Parms.AlphaBlendOption = AlphaBlendOption;
|
|
Parms.CustomBlendCurve = CustomBlendCurve;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.IsStateBlendingOut
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateResultReferenceNode (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAnimationStateMachineLibrary::IsStateBlendingOut(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "IsStateBlendingOut");
|
|
|
|
Params::UAnimationStateMachineLibrary_IsStateBlendingOut_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.IsStateBlendingIn
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateResultReferenceNode (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool UAnimationStateMachineLibrary::IsStateBlendingIn(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "IsStateBlendingIn");
|
|
|
|
Params::UAnimationStateMachineLibrary_IsStateBlendingIn_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.GetState
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateMachineReferenceNode (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class FName ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class FName UAnimationStateMachineLibrary::GetState(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateMachineReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "GetState");
|
|
|
|
Params::UAnimationStateMachineLibrary_GetState_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.GetRelevantAnimTimeRemainingFraction
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateResultReferenceNode (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAnimationStateMachineLibrary::GetRelevantAnimTimeRemainingFraction(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "GetRelevantAnimTimeRemainingFraction");
|
|
|
|
Params::UAnimationStateMachineLibrary_GetRelevantAnimTimeRemainingFraction_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.GetRelevantAnimTimeRemaining
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateResultReferenceNode (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAnimationStateMachineLibrary::GetRelevantAnimTimeRemaining(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "GetRelevantAnimTimeRemaining");
|
|
|
|
Params::UAnimationStateMachineLibrary_GetRelevantAnimTimeRemaining_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.ConvertToAnimationStateResultPure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateResultReferenceAnimationState (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAnimationStateMachineLibrary::ConvertToAnimationStateResultPure(struct FAnimNodeReference& Node, struct FAnimationStateResultReference* AnimationState, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "ConvertToAnimationStateResultPure");
|
|
|
|
Params::UAnimationStateMachineLibrary_ConvertToAnimationStateResultPure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (AnimationState != nullptr)
|
|
*AnimationState = std::move(Parms.AnimationState);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.ConvertToAnimationStateResult
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateResultReferenceAnimationState (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAnimationStateMachineLibrary::ConvertToAnimationStateResult(struct FAnimNodeReference& Node, struct FAnimationStateResultReference* AnimationState, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "ConvertToAnimationStateResult");
|
|
|
|
Params::UAnimationStateMachineLibrary_ConvertToAnimationStateResult_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (AnimationState != nullptr)
|
|
*AnimationState = std::move(Parms.AnimationState);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.ConvertToAnimationStateMachinePure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateMachineReferenceAnimationState (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAnimationStateMachineLibrary::ConvertToAnimationStateMachinePure(struct FAnimNodeReference& Node, struct FAnimationStateMachineReference* AnimationState, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "ConvertToAnimationStateMachinePure");
|
|
|
|
Params::UAnimationStateMachineLibrary_ConvertToAnimationStateMachinePure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (AnimationState != nullptr)
|
|
*AnimationState = std::move(Parms.AnimationState);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimationStateMachineLibrary.ConvertToAnimationStateMachine
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FAnimationStateMachineReferenceAnimationState (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UAnimationStateMachineLibrary::ConvertToAnimationStateMachine(struct FAnimNodeReference& Node, struct FAnimationStateMachineReference* AnimationState, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimationStateMachineLibrary", "ConvertToAnimationStateMachine");
|
|
|
|
Params::UAnimationStateMachineLibrary_ConvertToAnimationStateMachine_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (AnimationState != nullptr)
|
|
*AnimationState = std::move(Parms.AnimationState);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.AnimExecutionContextLibrary
|
|
// (None)
|
|
|
|
class UClass* UAnimExecutionContextLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AnimExecutionContextLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AnimExecutionContextLibrary AnimGraphRuntime.Default__AnimExecutionContextLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAnimExecutionContextLibrary* UAnimExecutionContextLibrary::GetDefaultObj()
|
|
{
|
|
static class UAnimExecutionContextLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAnimExecutionContextLibrary*>(UAnimExecutionContextLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.GetDeltaTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAnimExecutionContextLibrary::GetDeltaTime(struct FAnimUpdateContext& Context)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "GetDeltaTime");
|
|
|
|
Params::UAnimExecutionContextLibrary_GetDeltaTime_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.GetCurrentWeight
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UAnimExecutionContextLibrary::GetCurrentWeight(struct FAnimUpdateContext& Context)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "GetCurrentWeight");
|
|
|
|
Params::UAnimExecutionContextLibrary_GetCurrentWeight_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.GetAnimNodeReference
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class UAnimInstance* Instance (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// int32 Index (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAnimNodeReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FAnimNodeReference UAnimExecutionContextLibrary::GetAnimNodeReference(class UAnimInstance* Instance, int32 Index)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "GetAnimNodeReference");
|
|
|
|
Params::UAnimExecutionContextLibrary_GetAnimNodeReference_Params Parms{};
|
|
|
|
Parms.Instance = Instance;
|
|
Parms.Index = Index;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.GetAnimInstance
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimExecutionContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// class UAnimInstance* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAnimInstance* UAnimExecutionContextLibrary::GetAnimInstance(struct FAnimExecutionContext& Context)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "GetAnimInstance");
|
|
|
|
Params::UAnimExecutionContextLibrary_GetAnimInstance_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.ConvertToUpdateContext
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimExecutionContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// enum class EAnimExecutionContextConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAnimUpdateContext ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FAnimUpdateContext UAnimExecutionContextLibrary::ConvertToUpdateContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "ConvertToUpdateContext");
|
|
|
|
Params::UAnimExecutionContextLibrary_ConvertToUpdateContext_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.ConvertToPoseContext
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimExecutionContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// enum class EAnimExecutionContextConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAnimPoseContext ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FAnimPoseContext UAnimExecutionContextLibrary::ConvertToPoseContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "ConvertToPoseContext");
|
|
|
|
Params::UAnimExecutionContextLibrary_ConvertToPoseContext_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.ConvertToInitializationContext
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimExecutionContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// enum class EAnimExecutionContextConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAnimInitializationContext ReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FAnimInitializationContext UAnimExecutionContextLibrary::ConvertToInitializationContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "ConvertToInitializationContext");
|
|
|
|
Params::UAnimExecutionContextLibrary_ConvertToInitializationContext_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.AnimExecutionContextLibrary.ConvertToComponentSpacePoseContext
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimExecutionContext Context (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// enum class EAnimExecutionContextConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FAnimComponentSpacePoseContextReturnValue (Parm, OutParm, ReturnParm, NativeAccessSpecifierPublic)
|
|
|
|
struct FAnimComponentSpacePoseContext UAnimExecutionContextLibrary::ConvertToComponentSpacePoseContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("AnimExecutionContextLibrary", "ConvertToComponentSpacePoseContext");
|
|
|
|
Params::UAnimExecutionContextLibrary_ConvertToComponentSpacePoseContext_Params Parms{};
|
|
|
|
Parms.Context = Context;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.AnimNotify_PlayMontageNotify
|
|
// (None)
|
|
|
|
class UClass* UAnimNotify_PlayMontageNotify::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AnimNotify_PlayMontageNotify");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AnimNotify_PlayMontageNotify AnimGraphRuntime.Default__AnimNotify_PlayMontageNotify
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAnimNotify_PlayMontageNotify* UAnimNotify_PlayMontageNotify::GetDefaultObj()
|
|
{
|
|
static class UAnimNotify_PlayMontageNotify* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAnimNotify_PlayMontageNotify*>(UAnimNotify_PlayMontageNotify::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.AnimNotify_PlayMontageNotifyWindow
|
|
// (None)
|
|
|
|
class UClass* UAnimNotify_PlayMontageNotifyWindow::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AnimNotify_PlayMontageNotifyWindow");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AnimNotify_PlayMontageNotifyWindow AnimGraphRuntime.Default__AnimNotify_PlayMontageNotifyWindow
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAnimNotify_PlayMontageNotifyWindow* UAnimNotify_PlayMontageNotifyWindow::GetDefaultObj()
|
|
{
|
|
static class UAnimNotify_PlayMontageNotifyWindow* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAnimNotify_PlayMontageNotifyWindow*>(UAnimNotify_PlayMontageNotifyWindow::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.AnimSequencerInstance
|
|
// (None)
|
|
|
|
class UClass* UAnimSequencerInstance::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("AnimSequencerInstance");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// AnimSequencerInstance AnimGraphRuntime.Default__AnimSequencerInstance
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UAnimSequencerInstance* UAnimSequencerInstance::GetDefaultObj()
|
|
{
|
|
static class UAnimSequencerInstance* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UAnimSequencerInstance*>(UAnimSequencerInstance::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.KismetAnimationLibrary
|
|
// (None)
|
|
|
|
class UClass* UKismetAnimationLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("KismetAnimationLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// KismetAnimationLibrary AnimGraphRuntime.Default__KismetAnimationLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UKismetAnimationLibrary* UKismetAnimationLibrary::GetDefaultObj()
|
|
{
|
|
static class UKismetAnimationLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UKismetAnimationLibrary*>(UKismetAnimationLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_TwoBoneIK
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector RootPos (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector JointPos (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector EndPos (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector JointTarget (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector Effector (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector OutJointPos (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector OutEndPos (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bAllowStretching (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float StartStretchRatio (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float MaxStretchScale (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UKismetAnimationLibrary::K2_TwoBoneIK(struct FVector& RootPos, struct FVector& JointPos, struct FVector& EndPos, struct FVector& JointTarget, struct FVector& Effector, struct FVector* OutJointPos, struct FVector* OutEndPos, bool bAllowStretching, float StartStretchRatio, float MaxStretchScale)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_TwoBoneIK");
|
|
|
|
Params::UKismetAnimationLibrary_K2_TwoBoneIK_Params Parms{};
|
|
|
|
Parms.RootPos = RootPos;
|
|
Parms.JointPos = JointPos;
|
|
Parms.EndPos = EndPos;
|
|
Parms.JointTarget = JointTarget;
|
|
Parms.Effector = Effector;
|
|
Parms.bAllowStretching = bAllowStretching;
|
|
Parms.StartStretchRatio = StartStretchRatio;
|
|
Parms.MaxStretchScale = MaxStretchScale;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (OutJointPos != nullptr)
|
|
*OutJointPos = std::move(Parms.OutJointPos);
|
|
|
|
if (OutEndPos != nullptr)
|
|
*OutEndPos = std::move(Parms.OutEndPos);
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_StartProfilingTimer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
|
|
void UKismetAnimationLibrary::K2_StartProfilingTimer()
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_StartProfilingTimer");
|
|
|
|
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, nullptr);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_MakePerlinNoiseVectorAndRemap
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float X (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Y (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float Z (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMinX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMaxX (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMinY (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMaxY (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMinZ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMaxZ (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector UKismetAnimationLibrary::K2_MakePerlinNoiseVectorAndRemap(float X, float Y, float Z, float RangeOutMinX, float RangeOutMaxX, float RangeOutMinY, float RangeOutMaxY, float RangeOutMinZ, float RangeOutMaxZ)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_MakePerlinNoiseVectorAndRemap");
|
|
|
|
Params::UKismetAnimationLibrary_K2_MakePerlinNoiseVectorAndRemap_Params Parms{};
|
|
|
|
Parms.X = X;
|
|
Parms.Y = Y;
|
|
Parms.Z = Z;
|
|
Parms.RangeOutMinX = RangeOutMinX;
|
|
Parms.RangeOutMaxX = RangeOutMaxX;
|
|
Parms.RangeOutMinY = RangeOutMinY;
|
|
Parms.RangeOutMaxY = RangeOutMaxY;
|
|
Parms.RangeOutMinZ = RangeOutMinZ;
|
|
Parms.RangeOutMaxZ = RangeOutMaxZ;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_MakePerlinNoiseAndRemap
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// float Value (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float RangeOutMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UKismetAnimationLibrary::K2_MakePerlinNoiseAndRemap(float Value, float RangeOutMin, float RangeOutMax)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_MakePerlinNoiseAndRemap");
|
|
|
|
Params::UKismetAnimationLibrary_K2_MakePerlinNoiseAndRemap_Params Parms{};
|
|
|
|
Parms.Value = Value;
|
|
Parms.RangeOutMin = RangeOutMin;
|
|
Parms.RangeOutMax = RangeOutMax;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_LookAt
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FTransform CurrentTransform (ConstParm, Parm, OutParm, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector TargetPosition (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector LookAtVector (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bUseUpVector (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector UpVector (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ClampConeInDegree (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FTransform ReturnValue (Parm, OutParm, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FTransform UKismetAnimationLibrary::K2_LookAt(struct FTransform& CurrentTransform, struct FVector& TargetPosition, const struct FVector& LookAtVector, bool bUseUpVector, const struct FVector& UpVector, float ClampConeInDegree)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_LookAt");
|
|
|
|
Params::UKismetAnimationLibrary_K2_LookAt_Params Parms{};
|
|
|
|
Parms.CurrentTransform = CurrentTransform;
|
|
Parms.TargetPosition = TargetPosition;
|
|
Parms.LookAtVector = LookAtVector;
|
|
Parms.bUseUpVector = bUseUpVector;
|
|
Parms.UpVector = UpVector;
|
|
Parms.ClampConeInDegree = ClampConeInDegree;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_EndProfilingTimer
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// bool bLog (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FString LogPrefix (Parm, ZeroConstructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UKismetAnimationLibrary::K2_EndProfilingTimer(bool bLog, const class FString& LogPrefix)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_EndProfilingTimer");
|
|
|
|
Params::UKismetAnimationLibrary_K2_EndProfilingTimer_Params Parms{};
|
|
|
|
Parms.bLog = bLog;
|
|
Parms.LogPrefix = LogPrefix;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_DistanceBetweenTwoSocketsAndMapRange
|
|
// (Final, Native, Static, Public, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* Component (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SocketOrBoneNameA (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class ERelativeTransformSpace SocketSpaceA (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SocketOrBoneNameB (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class ERelativeTransformSpace SocketSpaceB (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bRemapRange (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InRangeMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float InRangeMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float OutRangeMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float OutRangeMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UKismetAnimationLibrary::K2_DistanceBetweenTwoSocketsAndMapRange(class USkeletalMeshComponent* Component, class FName SocketOrBoneNameA, enum class ERelativeTransformSpace SocketSpaceA, class FName SocketOrBoneNameB, enum class ERelativeTransformSpace SocketSpaceB, bool bRemapRange, float InRangeMin, float InRangeMax, float OutRangeMin, float OutRangeMax)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_DistanceBetweenTwoSocketsAndMapRange");
|
|
|
|
Params::UKismetAnimationLibrary_K2_DistanceBetweenTwoSocketsAndMapRange_Params Parms{};
|
|
|
|
Parms.Component = Component;
|
|
Parms.SocketOrBoneNameA = SocketOrBoneNameA;
|
|
Parms.SocketSpaceA = SocketSpaceA;
|
|
Parms.SocketOrBoneNameB = SocketOrBoneNameB;
|
|
Parms.SocketSpaceB = SocketSpaceB;
|
|
Parms.bRemapRange = bRemapRange;
|
|
Parms.InRangeMin = InRangeMin;
|
|
Parms.InRangeMax = InRangeMax;
|
|
Parms.OutRangeMin = OutRangeMin;
|
|
Parms.OutRangeMax = OutRangeMax;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_DirectionBetweenSockets
|
|
// (Final, Native, Static, Public, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* Component (ConstParm, Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SocketOrBoneNameFrom (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SocketOrBoneNameTo (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
struct FVector UKismetAnimationLibrary::K2_DirectionBetweenSockets(class USkeletalMeshComponent* Component, class FName SocketOrBoneNameFrom, class FName SocketOrBoneNameTo)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_DirectionBetweenSockets");
|
|
|
|
Params::UKismetAnimationLibrary_K2_DirectionBetweenSockets_Params Parms{};
|
|
|
|
Parms.Component = Component;
|
|
Parms.SocketOrBoneNameFrom = SocketOrBoneNameFrom;
|
|
Parms.SocketOrBoneNameTo = SocketOrBoneNameTo;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_CalculateVelocityFromSockets
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float DeltaSeconds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class USkeletalMeshComponent* Component (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName SocketOrBoneName (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName ReferenceSocketOrBone (ConstParm, Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class ERelativeTransformSpace SocketSpace (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector OffsetInBoneSpace (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FPositionHistory History (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 NumberOfSamples (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float VelocityMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float VelocityMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// enum class EEasingFuncType EasingType (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FRuntimeFloatCurve CustomCurve (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UKismetAnimationLibrary::K2_CalculateVelocityFromSockets(float DeltaSeconds, class USkeletalMeshComponent* Component, class FName SocketOrBoneName, class FName ReferenceSocketOrBone, enum class ERelativeTransformSpace SocketSpace, const struct FVector& OffsetInBoneSpace, struct FPositionHistory& History, int32 NumberOfSamples, float VelocityMin, float VelocityMax, enum class EEasingFuncType EasingType, struct FRuntimeFloatCurve& CustomCurve)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_CalculateVelocityFromSockets");
|
|
|
|
Params::UKismetAnimationLibrary_K2_CalculateVelocityFromSockets_Params Parms{};
|
|
|
|
Parms.DeltaSeconds = DeltaSeconds;
|
|
Parms.Component = Component;
|
|
Parms.SocketOrBoneName = SocketOrBoneName;
|
|
Parms.ReferenceSocketOrBone = ReferenceSocketOrBone;
|
|
Parms.SocketSpace = SocketSpace;
|
|
Parms.OffsetInBoneSpace = OffsetInBoneSpace;
|
|
Parms.History = History;
|
|
Parms.NumberOfSamples = NumberOfSamples;
|
|
Parms.VelocityMin = VelocityMin;
|
|
Parms.VelocityMax = VelocityMax;
|
|
Parms.EasingType = EasingType;
|
|
Parms.CustomCurve = CustomCurve;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.K2_CalculateVelocityFromPositionHistory
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable)
|
|
// Parameters:
|
|
// float DeltaSeconds (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FVector Position (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FPositionHistory History (Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// int32 NumberOfSamples (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float VelocityMin (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float VelocityMax (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UKismetAnimationLibrary::K2_CalculateVelocityFromPositionHistory(float DeltaSeconds, const struct FVector& Position, struct FPositionHistory& History, int32 NumberOfSamples, float VelocityMin, float VelocityMax)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "K2_CalculateVelocityFromPositionHistory");
|
|
|
|
Params::UKismetAnimationLibrary_K2_CalculateVelocityFromPositionHistory_Params Parms{};
|
|
|
|
Parms.DeltaSeconds = DeltaSeconds;
|
|
Parms.Position = Position;
|
|
Parms.History = History;
|
|
Parms.NumberOfSamples = NumberOfSamples;
|
|
Parms.VelocityMin = VelocityMin;
|
|
Parms.VelocityMax = VelocityMax;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.KismetAnimationLibrary.CalculateDirection
|
|
// (Final, Native, Static, Public, HasOutParams, HasDefaults, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FVector Velocity (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FRotator BaseRotation (ConstParm, Parm, OutParm, ZeroConstructor, ReferenceParm, IsPlainOldData, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float UKismetAnimationLibrary::CalculateDirection(struct FVector& Velocity, struct FRotator& BaseRotation)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("KismetAnimationLibrary", "CalculateDirection");
|
|
|
|
Params::UKismetAnimationLibrary_CalculateDirection_Params Parms{};
|
|
|
|
Parms.Velocity = Velocity;
|
|
Parms.BaseRotation = BaseRotation;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.LinkedAnimGraphLibrary
|
|
// (None)
|
|
|
|
class UClass* ULinkedAnimGraphLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("LinkedAnimGraphLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// LinkedAnimGraphLibrary AnimGraphRuntime.Default__LinkedAnimGraphLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ULinkedAnimGraphLibrary* ULinkedAnimGraphLibrary::GetDefaultObj()
|
|
{
|
|
static class ULinkedAnimGraphLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ULinkedAnimGraphLibrary*>(ULinkedAnimGraphLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LinkedAnimGraphLibrary.HasLinkedAnimInstance
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinkedAnimGraphReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool ULinkedAnimGraphLibrary::HasLinkedAnimInstance(struct FLinkedAnimGraphReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LinkedAnimGraphLibrary", "HasLinkedAnimInstance");
|
|
|
|
Params::ULinkedAnimGraphLibrary_HasLinkedAnimInstance_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LinkedAnimGraphLibrary.GetLinkedAnimInstance
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FLinkedAnimGraphReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimInstance* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAnimInstance* ULinkedAnimGraphLibrary::GetLinkedAnimInstance(struct FLinkedAnimGraphReference& Node)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LinkedAnimGraphLibrary", "GetLinkedAnimInstance");
|
|
|
|
Params::ULinkedAnimGraphLibrary_GetLinkedAnimInstance_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LinkedAnimGraphLibrary.ConvertToLinkedAnimGraphPure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FLinkedAnimGraphReference LinkedAnimGraph (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void ULinkedAnimGraphLibrary::ConvertToLinkedAnimGraphPure(struct FAnimNodeReference& Node, struct FLinkedAnimGraphReference* LinkedAnimGraph, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LinkedAnimGraphLibrary", "ConvertToLinkedAnimGraphPure");
|
|
|
|
Params::ULinkedAnimGraphLibrary_ConvertToLinkedAnimGraphPure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (LinkedAnimGraph != nullptr)
|
|
*LinkedAnimGraph = std::move(Parms.LinkedAnimGraph);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.LinkedAnimGraphLibrary.ConvertToLinkedAnimGraph
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FLinkedAnimGraphReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FLinkedAnimGraphReference ULinkedAnimGraphLibrary::ConvertToLinkedAnimGraph(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("LinkedAnimGraphLibrary", "ConvertToLinkedAnimGraph");
|
|
|
|
Params::ULinkedAnimGraphLibrary_ConvertToLinkedAnimGraph_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.PlayMontageCallbackProxy
|
|
// (None)
|
|
|
|
class UClass* UPlayMontageCallbackProxy::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("PlayMontageCallbackProxy");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// PlayMontageCallbackProxy AnimGraphRuntime.Default__PlayMontageCallbackProxy
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class UPlayMontageCallbackProxy* UPlayMontageCallbackProxy::GetDefaultObj()
|
|
{
|
|
static class UPlayMontageCallbackProxy* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<UPlayMontageCallbackProxy*>(UPlayMontageCallbackProxy::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyEndReceived
|
|
// (Final, Native, Protected, HasOutParams)
|
|
// Parameters:
|
|
// class FName NotifyName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBranchingPointNotifyPayloadBranchingPointNotifyPayload (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UPlayMontageCallbackProxy::OnNotifyEndReceived(class FName NotifyName, struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PlayMontageCallbackProxy", "OnNotifyEndReceived");
|
|
|
|
Params::UPlayMontageCallbackProxy_OnNotifyEndReceived_Params Parms{};
|
|
|
|
Parms.NotifyName = NotifyName;
|
|
Parms.BranchingPointNotifyPayload = BranchingPointNotifyPayload;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnNotifyBeginReceived
|
|
// (Final, Native, Protected, HasOutParams)
|
|
// Parameters:
|
|
// class FName NotifyName (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FBranchingPointNotifyPayloadBranchingPointNotifyPayload (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
void UPlayMontageCallbackProxy::OnNotifyBeginReceived(class FName NotifyName, struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PlayMontageCallbackProxy", "OnNotifyBeginReceived");
|
|
|
|
Params::UPlayMontageCallbackProxy_OnNotifyBeginReceived_Params Parms{};
|
|
|
|
Parms.NotifyName = NotifyName;
|
|
Parms.BranchingPointNotifyPayload = BranchingPointNotifyPayload;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageEnded
|
|
// (Final, Native, Protected)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bInterrupted (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UPlayMontageCallbackProxy::OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PlayMontageCallbackProxy", "OnMontageEnded");
|
|
|
|
Params::UPlayMontageCallbackProxy_OnMontageEnded_Params Parms{};
|
|
|
|
Parms.Montage = Montage;
|
|
Parms.bInterrupted = bInterrupted;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.PlayMontageCallbackProxy.OnMontageBlendingOut
|
|
// (Final, Native, Protected)
|
|
// Parameters:
|
|
// class UAnimMontage* Montage (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// bool bInterrupted (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void UPlayMontageCallbackProxy::OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PlayMontageCallbackProxy", "OnMontageBlendingOut");
|
|
|
|
Params::UPlayMontageCallbackProxy_OnMontageBlendingOut_Params Parms{};
|
|
|
|
Parms.Montage = Montage;
|
|
Parms.bInterrupted = bInterrupted;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.PlayMontageCallbackProxy.CreateProxyObjectForPlayMontage
|
|
// (Final, Native, Static, Public, BlueprintCallable)
|
|
// Parameters:
|
|
// class USkeletalMeshComponent* InSkeletalMeshComponent (Parm, ZeroConstructor, InstancedReference, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UAnimMontage* MontageToPlay (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float PlayRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float StartingPosition (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class FName StartingSection (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// class UPlayMontageCallbackProxy* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UPlayMontageCallbackProxy* UPlayMontageCallbackProxy::CreateProxyObjectForPlayMontage(class USkeletalMeshComponent* InSkeletalMeshComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, class FName StartingSection)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("PlayMontageCallbackProxy", "CreateProxyObjectForPlayMontage");
|
|
|
|
Params::UPlayMontageCallbackProxy_CreateProxyObjectForPlayMontage_Params Parms{};
|
|
|
|
Parms.InSkeletalMeshComponent = InSkeletalMeshComponent;
|
|
Parms.MontageToPlay = MontageToPlay;
|
|
Parms.PlayRate = PlayRate;
|
|
Parms.StartingPosition = StartingPosition;
|
|
Parms.StartingSection = StartingSection;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.SequenceEvaluatorLibrary
|
|
// (None)
|
|
|
|
class UClass* USequenceEvaluatorLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SequenceEvaluatorLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SequenceEvaluatorLibrary AnimGraphRuntime.Default__SequenceEvaluatorLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USequenceEvaluatorLibrary* USequenceEvaluatorLibrary::GetDefaultObj()
|
|
{
|
|
static class USequenceEvaluatorLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USequenceEvaluatorLibrary*>(USequenceEvaluatorLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.SetSequenceWithInertialBlending
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float BlendTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequenceEvaluatorReference USequenceEvaluatorLibrary::SetSequenceWithInertialBlending(struct FAnimUpdateContext& UpdateContext, struct FSequenceEvaluatorReference& SequenceEvaluator, class UAnimSequenceBase* Sequence, float BlendTime)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "SetSequenceWithInertialBlending");
|
|
|
|
Params::USequenceEvaluatorLibrary_SetSequenceWithInertialBlending_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.SequenceEvaluator = SequenceEvaluator;
|
|
Parms.Sequence = Sequence;
|
|
Parms.BlendTime = BlendTime;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.SetSequence
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequenceEvaluatorReference USequenceEvaluatorLibrary::SetSequence(struct FSequenceEvaluatorReference& SequenceEvaluator, class UAnimSequenceBase* Sequence)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "SetSequence");
|
|
|
|
Params::USequenceEvaluatorLibrary_SetSequence_Params Parms{};
|
|
|
|
Parms.SequenceEvaluator = SequenceEvaluator;
|
|
Parms.Sequence = Sequence;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.SetExplicitTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequenceEvaluatorReference USequenceEvaluatorLibrary::SetExplicitTime(struct FSequenceEvaluatorReference& SequenceEvaluator, float Time)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "SetExplicitTime");
|
|
|
|
Params::USequenceEvaluatorLibrary_SetExplicitTime_Params Parms{};
|
|
|
|
Parms.SequenceEvaluator = SequenceEvaluator;
|
|
Parms.Time = Time;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.GetSequence
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAnimSequenceBase* USequenceEvaluatorLibrary::GetSequence(struct FSequenceEvaluatorReference& SequenceEvaluator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "GetSequence");
|
|
|
|
Params::USequenceEvaluatorLibrary_GetSequence_Params Parms{};
|
|
|
|
Parms.SequenceEvaluator = SequenceEvaluator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.GetAccumulatedTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USequenceEvaluatorLibrary::GetAccumulatedTime(struct FSequenceEvaluatorReference& SequenceEvaluator)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "GetAccumulatedTime");
|
|
|
|
Params::USequenceEvaluatorLibrary_GetAccumulatedTime_Params Parms{};
|
|
|
|
Parms.SequenceEvaluator = SequenceEvaluator;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.ConvertToSequenceEvaluatorPure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USequenceEvaluatorLibrary::ConvertToSequenceEvaluatorPure(struct FAnimNodeReference& Node, struct FSequenceEvaluatorReference* SequenceEvaluator, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "ConvertToSequenceEvaluatorPure");
|
|
|
|
Params::USequenceEvaluatorLibrary_ConvertToSequenceEvaluatorPure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (SequenceEvaluator != nullptr)
|
|
*SequenceEvaluator = std::move(Parms.SequenceEvaluator);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.ConvertToSequenceEvaluator
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequenceEvaluatorReference USequenceEvaluatorLibrary::ConvertToSequenceEvaluator(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "ConvertToSequenceEvaluator");
|
|
|
|
Params::USequenceEvaluatorLibrary_ConvertToSequenceEvaluator_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequenceEvaluatorLibrary.AdvanceTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference SequenceEvaluator (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float PlayRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequenceEvaluatorReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequenceEvaluatorReference USequenceEvaluatorLibrary::AdvanceTime(struct FAnimUpdateContext& UpdateContext, struct FSequenceEvaluatorReference& SequenceEvaluator, float PlayRate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequenceEvaluatorLibrary", "AdvanceTime");
|
|
|
|
Params::USequenceEvaluatorLibrary_AdvanceTime_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.SequenceEvaluator = SequenceEvaluator;
|
|
Parms.PlayRate = PlayRate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.SequencePlayerLibrary
|
|
// (None)
|
|
|
|
class UClass* USequencePlayerLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SequencePlayerLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SequencePlayerLibrary AnimGraphRuntime.Default__SequencePlayerLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USequencePlayerLibrary* USequencePlayerLibrary::GetDefaultObj()
|
|
{
|
|
static class USequencePlayerLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USequencePlayerLibrary*>(USequencePlayerLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.SetStartPosition
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float StartPosition (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::SetStartPosition(struct FSequencePlayerReference& SequencePlayer, float StartPosition)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "SetStartPosition");
|
|
|
|
Params::USequencePlayerLibrary_SetStartPosition_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.StartPosition = StartPosition;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.SetSequenceWithInertialBlending
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimUpdateContext UpdateContext (ConstParm, Parm, OutParm, ReferenceParm, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float BlendTime (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::SetSequenceWithInertialBlending(struct FAnimUpdateContext& UpdateContext, struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase* Sequence, float BlendTime)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "SetSequenceWithInertialBlending");
|
|
|
|
Params::USequencePlayerLibrary_SetSequenceWithInertialBlending_Params Parms{};
|
|
|
|
Parms.UpdateContext = UpdateContext;
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.Sequence = Sequence;
|
|
Parms.BlendTime = BlendTime;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.SetSequence
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* Sequence (Parm, ZeroConstructor, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::SetSequence(struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase* Sequence)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "SetSequence");
|
|
|
|
Params::USequencePlayerLibrary_SetSequence_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.Sequence = Sequence;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.SetPlayRate
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float PlayRate (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::SetPlayRate(struct FSequencePlayerReference& SequencePlayer, float PlayRate)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "SetPlayRate");
|
|
|
|
Params::USequencePlayerLibrary_SetPlayRate_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.PlayRate = PlayRate;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.SetAccumulatedTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Time (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::SetAccumulatedTime(struct FSequencePlayerReference& SequencePlayer, float Time)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "SetAccumulatedTime");
|
|
|
|
Params::USequencePlayerLibrary_SetAccumulatedTime_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.Time = Time;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.GetStartPosition
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USequencePlayerLibrary::GetStartPosition(struct FSequencePlayerReference& SequencePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "GetStartPosition");
|
|
|
|
Params::USequencePlayerLibrary_GetStartPosition_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.GetSequencePure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
class UAnimSequenceBase* USequencePlayerLibrary::GetSequencePure(struct FSequencePlayerReference& SequencePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "GetSequencePure");
|
|
|
|
Params::USequencePlayerLibrary_GetSequencePure_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.GetSequence
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// class UAnimSequenceBase* SequenceBase (Parm, OutParm, ZeroConstructor, ReferenceParm, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::GetSequence(struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase*& SequenceBase)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "GetSequence");
|
|
|
|
Params::USequencePlayerLibrary_GetSequence_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.SequenceBase = SequenceBase;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.GetPlayRate
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USequencePlayerLibrary::GetPlayRate(struct FSequencePlayerReference& SequencePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "GetPlayRate");
|
|
|
|
Params::USequencePlayerLibrary_GetPlayRate_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.GetLoopAnimation
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
bool USequencePlayerLibrary::GetLoopAnimation(struct FSequencePlayerReference& SequencePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "GetLoopAnimation");
|
|
|
|
Params::USequencePlayerLibrary_GetLoopAnimation_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.GetAccumulatedTime
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USequencePlayerLibrary::GetAccumulatedTime(struct FSequencePlayerReference& SequencePlayer)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "GetAccumulatedTime");
|
|
|
|
Params::USequencePlayerLibrary_GetAccumulatedTime_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.ConvertToSequencePlayerPure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference SequencePlayer (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USequencePlayerLibrary::ConvertToSequencePlayerPure(struct FAnimNodeReference& Node, struct FSequencePlayerReference* SequencePlayer, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "ConvertToSequencePlayerPure");
|
|
|
|
Params::USequencePlayerLibrary_ConvertToSequencePlayerPure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (SequencePlayer != nullptr)
|
|
*SequencePlayer = std::move(Parms.SequencePlayer);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.ConvertToSequencePlayer
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSequencePlayerReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSequencePlayerReference USequencePlayerLibrary::ConvertToSequencePlayer(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "ConvertToSequencePlayer");
|
|
|
|
Params::USequencePlayerLibrary_ConvertToSequencePlayer_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SequencePlayerLibrary.ComputePlayRateFromDuration
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSequencePlayerReference SequencePlayer (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Duration (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USequencePlayerLibrary::ComputePlayRateFromDuration(struct FSequencePlayerReference& SequencePlayer, float Duration)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SequencePlayerLibrary", "ComputePlayRateFromDuration");
|
|
|
|
Params::USequencePlayerLibrary_ComputePlayRateFromDuration_Params Parms{};
|
|
|
|
Parms.SequencePlayer = SequencePlayer;
|
|
Parms.Duration = Duration;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.SequencerAnimationSupport
|
|
// (None)
|
|
|
|
class UClass* ISequencerAnimationSupport::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SequencerAnimationSupport");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SequencerAnimationSupport AnimGraphRuntime.Default__SequencerAnimationSupport
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class ISequencerAnimationSupport* ISequencerAnimationSupport::GetDefaultObj()
|
|
{
|
|
static class ISequencerAnimationSupport* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<ISequencerAnimationSupport*>(ISequencerAnimationSupport::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Class AnimGraphRuntime.SkeletalControlLibrary
|
|
// (None)
|
|
|
|
class UClass* USkeletalControlLibrary::StaticClass()
|
|
{
|
|
static class UClass* Clss = nullptr;
|
|
|
|
if (!Clss)
|
|
Clss = UObject::FindClassFast("SkeletalControlLibrary");
|
|
|
|
return Clss;
|
|
}
|
|
|
|
|
|
// SkeletalControlLibrary AnimGraphRuntime.Default__SkeletalControlLibrary
|
|
// (Public, ClassDefaultObject, ArchetypeObject)
|
|
|
|
class USkeletalControlLibrary* USkeletalControlLibrary::GetDefaultObj()
|
|
{
|
|
static class USkeletalControlLibrary* Default = nullptr;
|
|
|
|
if (!Default)
|
|
Default = static_cast<USkeletalControlLibrary*>(USkeletalControlLibrary::StaticClass()->DefaultObject);
|
|
|
|
return Default;
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SkeletalControlLibrary.SetAlpha
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FSkeletalControlReference SkeletalControl (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float Alpha (Parm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSkeletalControlReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSkeletalControlReference USkeletalControlLibrary::SetAlpha(struct FSkeletalControlReference& SkeletalControl, float Alpha)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SkeletalControlLibrary", "SetAlpha");
|
|
|
|
Params::USkeletalControlLibrary_SetAlpha_Params Parms{};
|
|
|
|
Parms.SkeletalControl = SkeletalControl;
|
|
Parms.Alpha = Alpha;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SkeletalControlLibrary.GetAlpha
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FSkeletalControlReference SkeletalControl (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// float ReturnValue (Parm, OutParm, ZeroConstructor, ReturnParm, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
float USkeletalControlLibrary::GetAlpha(struct FSkeletalControlReference& SkeletalControl)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SkeletalControlLibrary", "GetAlpha");
|
|
|
|
Params::USkeletalControlLibrary_GetAlpha_Params Parms{};
|
|
|
|
Parms.SkeletalControl = SkeletalControl;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SkeletalControlLibrary.ConvertToSkeletalControlPure
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable, BlueprintPure)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// struct FSkeletalControlReference SkeletalControl (Parm, OutParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// bool Result (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
|
|
void USkeletalControlLibrary::ConvertToSkeletalControlPure(struct FAnimNodeReference& Node, struct FSkeletalControlReference* SkeletalControl, bool* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SkeletalControlLibrary", "ConvertToSkeletalControlPure");
|
|
|
|
Params::USkeletalControlLibrary_ConvertToSkeletalControlPure_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (SkeletalControl != nullptr)
|
|
*SkeletalControl = std::move(Parms.SkeletalControl);
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
}
|
|
|
|
|
|
// Function AnimGraphRuntime.SkeletalControlLibrary.ConvertToSkeletalControl
|
|
// (Final, Native, Static, Public, HasOutParams, BlueprintCallable)
|
|
// Parameters:
|
|
// struct FAnimNodeReference Node (ConstParm, Parm, OutParm, ReferenceParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
// enum class EAnimNodeReferenceConversionResultResult (Parm, OutParm, ZeroConstructor, IsPlainOldData, NoDestructor, HasGetValueTypeHash, NativeAccessSpecifierPublic)
|
|
// struct FSkeletalControlReference ReturnValue (Parm, OutParm, ReturnParm, NoDestructor, NativeAccessSpecifierPublic)
|
|
|
|
struct FSkeletalControlReference USkeletalControlLibrary::ConvertToSkeletalControl(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result)
|
|
{
|
|
static class UFunction* Func = nullptr;
|
|
|
|
if (!Func)
|
|
Func = Class->GetFunction("SkeletalControlLibrary", "ConvertToSkeletalControl");
|
|
|
|
Params::USkeletalControlLibrary_ConvertToSkeletalControl_Params Parms{};
|
|
|
|
Parms.Node = Node;
|
|
|
|
auto Flgs = Func->FunctionFlags;
|
|
Func->FunctionFlags |= 0x400;
|
|
|
|
UObject::ProcessEvent(Func, &Parms);
|
|
|
|
|
|
Func->FunctionFlags = Flgs;
|
|
|
|
if (Result != nullptr)
|
|
*Result = Parms.Result;
|
|
|
|
return Parms.ReturnValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|