#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::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::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::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::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::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::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::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::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::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::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::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::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::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::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; } }