mirror of
https://github.com/swordbluesword/PalWorld-NetCrack.git
synced 2025-04-28 18:37:16 +09:00
9a743d2b16
- Adjusted SDK UGameViewportClient class members and padding - Created helper function to get local player - precompile headers for SDK - SDK made into a static library ( single compile as its never changed )
259 lines
16 KiB
C++
259 lines
16 KiB
C++
#pragma once
|
|
|
|
// Dumped with Dumper-7!
|
|
|
|
|
|
namespace SDK
|
|
{
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
// CLASSES
|
|
//---------------------------------------------------------------------------------------------------------------------
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.BlendSpacePlayerLibrary
|
|
class UBlendSpacePlayerLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class UBlendSpacePlayerLibrary* GetDefaultObj();
|
|
|
|
bool ShouldResetPlayTimeWhenBlendSpaceChanges(struct FBlendSpacePlayerReference& BlendSpacePlayer);
|
|
struct FBlendSpacePlayerReference SetResetPlayTimeWhenBlendSpaceChanges(struct FBlendSpacePlayerReference& BlendSpacePlayer, bool bReset);
|
|
struct FBlendSpacePlayerReference SetPlayRate(struct FBlendSpacePlayerReference& BlendSpacePlayer, float PlayRate);
|
|
struct FBlendSpacePlayerReference SetLoop(struct FBlendSpacePlayerReference& BlendSpacePlayer, bool bLoop);
|
|
struct FBlendSpacePlayerReference SetBlendSpaceWithInertialBlending(struct FAnimUpdateContext& UpdateContext, struct FBlendSpacePlayerReference& BlendSpacePlayer, class UBlendSpace* BlendSpace, float BlendTime);
|
|
struct FBlendSpacePlayerReference SetBlendSpace(struct FBlendSpacePlayerReference& BlendSpacePlayer, class UBlendSpace* BlendSpace);
|
|
float GetStartPosition(struct FBlendSpacePlayerReference& BlendSpacePlayer);
|
|
struct FVector GetPosition(struct FBlendSpacePlayerReference& BlendSpacePlayer);
|
|
float GetPlayRate(struct FBlendSpacePlayerReference& BlendSpacePlayer);
|
|
bool GetLoop(struct FBlendSpacePlayerReference& BlendSpacePlayer);
|
|
class UBlendSpace* GetBlendSpace(struct FBlendSpacePlayerReference& BlendSpacePlayer);
|
|
void ConvertToBlendSpacePlayerPure(struct FAnimNodeReference& Node, struct FBlendSpacePlayerReference* BlendSpacePlayer, bool* Result);
|
|
struct FBlendSpacePlayerReference ConvertToBlendSpacePlayer(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.LayeredBoneBlendLibrary
|
|
class ULayeredBoneBlendLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class ULayeredBoneBlendLibrary* GetDefaultObj();
|
|
|
|
struct FLayeredBoneBlendReference SetBlendMask(struct FAnimUpdateContext& UpdateContext, struct FLayeredBoneBlendReference& LayeredBoneBlend, int32 PoseIndex, class FName BlendMaskName);
|
|
int32 GetNumPoses(struct FLayeredBoneBlendReference& LayeredBoneBlend);
|
|
struct FLayeredBoneBlendReference ConvertToLayeredBoneBlend(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result);
|
|
void ConvertToLayeredBlendPerBonePure(struct FAnimNodeReference& Node, struct FLayeredBoneBlendReference* LayeredBoneBlend, bool* Result);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.AnimationStateMachineLibrary
|
|
class UAnimationStateMachineLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class UAnimationStateMachineLibrary* GetDefaultObj();
|
|
|
|
void 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);
|
|
bool IsStateBlendingOut(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node);
|
|
bool IsStateBlendingIn(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node);
|
|
class FName GetState(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateMachineReference& Node);
|
|
float GetRelevantAnimTimeRemainingFraction(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node);
|
|
float GetRelevantAnimTimeRemaining(struct FAnimUpdateContext& UpdateContext, struct FAnimationStateResultReference& Node);
|
|
void ConvertToAnimationStateResultPure(struct FAnimNodeReference& Node, struct FAnimationStateResultReference* AnimationState, bool* Result);
|
|
void ConvertToAnimationStateResult(struct FAnimNodeReference& Node, struct FAnimationStateResultReference* AnimationState, enum class EAnimNodeReferenceConversionResult* Result);
|
|
void ConvertToAnimationStateMachinePure(struct FAnimNodeReference& Node, struct FAnimationStateMachineReference* AnimationState, bool* Result);
|
|
void ConvertToAnimationStateMachine(struct FAnimNodeReference& Node, struct FAnimationStateMachineReference* AnimationState, enum class EAnimNodeReferenceConversionResult* Result);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.AnimExecutionContextLibrary
|
|
class UAnimExecutionContextLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class UAnimExecutionContextLibrary* GetDefaultObj();
|
|
|
|
float GetDeltaTime(struct FAnimUpdateContext& Context);
|
|
float GetCurrentWeight(struct FAnimUpdateContext& Context);
|
|
struct FAnimNodeReference GetAnimNodeReference(class UAnimInstance* Instance, int32 Index);
|
|
class UAnimInstance* GetAnimInstance(struct FAnimExecutionContext& Context);
|
|
struct FAnimUpdateContext ConvertToUpdateContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result);
|
|
struct FAnimPoseContext ConvertToPoseContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result);
|
|
struct FAnimInitializationContext ConvertToInitializationContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result);
|
|
struct FAnimComponentSpacePoseContext ConvertToComponentSpacePoseContext(struct FAnimExecutionContext& Context, enum class EAnimExecutionContextConversionResult* Result);
|
|
};
|
|
|
|
// 0x8 (0x40 - 0x38)
|
|
// Class AnimGraphRuntime.AnimNotify_PlayMontageNotify
|
|
class UAnimNotify_PlayMontageNotify : public UAnimNotify
|
|
{
|
|
public:
|
|
class FName NotifyName; // 0x38(0x8)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
static class UClass* StaticClass();
|
|
static class UAnimNotify_PlayMontageNotify* GetDefaultObj();
|
|
|
|
};
|
|
|
|
// 0x8 (0x38 - 0x30)
|
|
// Class AnimGraphRuntime.AnimNotify_PlayMontageNotifyWindow
|
|
class UAnimNotify_PlayMontageNotifyWindow : public UAnimNotifyState
|
|
{
|
|
public:
|
|
class FName NotifyName; // 0x30(0x8)(Edit, BlueprintVisible, BlueprintReadOnly, ZeroConstructor, IsPlainOldData, NoDestructor, Protected, HasGetValueTypeHash, NativeAccessSpecifierProtected)
|
|
|
|
static class UClass* StaticClass();
|
|
static class UAnimNotify_PlayMontageNotifyWindow* GetDefaultObj();
|
|
|
|
};
|
|
|
|
// 0x8 (0x350 - 0x348)
|
|
// Class AnimGraphRuntime.AnimSequencerInstance
|
|
class UAnimSequencerInstance : public UAnimInstance
|
|
{
|
|
public:
|
|
uint8 Pad_208E[0x8]; // Fixing Size Of Struct [ Dumper-7 ]
|
|
|
|
static class UClass* StaticClass();
|
|
static class UAnimSequencerInstance* GetDefaultObj();
|
|
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.KismetAnimationLibrary
|
|
class UKismetAnimationLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class UKismetAnimationLibrary* GetDefaultObj();
|
|
|
|
void 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);
|
|
void K2_StartProfilingTimer();
|
|
struct FVector K2_MakePerlinNoiseVectorAndRemap(float X, float Y, float Z, float RangeOutMinX, float RangeOutMaxX, float RangeOutMinY, float RangeOutMaxY, float RangeOutMinZ, float RangeOutMaxZ);
|
|
float K2_MakePerlinNoiseAndRemap(float Value, float RangeOutMin, float RangeOutMax);
|
|
struct FTransform K2_LookAt(struct FTransform& CurrentTransform, struct FVector& TargetPosition, const struct FVector& LookAtVector, bool bUseUpVector, const struct FVector& UpVector, float ClampConeInDegree);
|
|
float K2_EndProfilingTimer(bool bLog, const class FString& LogPrefix);
|
|
float 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);
|
|
struct FVector K2_DirectionBetweenSockets(class USkeletalMeshComponent* Component, class FName SocketOrBoneNameFrom, class FName SocketOrBoneNameTo);
|
|
float 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);
|
|
float K2_CalculateVelocityFromPositionHistory(float DeltaSeconds, const struct FVector& Position, struct FPositionHistory& History, int32 NumberOfSamples, float VelocityMin, float VelocityMax);
|
|
float CalculateDirection(struct FVector& Velocity, struct FRotator& BaseRotation);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.LinkedAnimGraphLibrary
|
|
class ULinkedAnimGraphLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class ULinkedAnimGraphLibrary* GetDefaultObj();
|
|
|
|
bool HasLinkedAnimInstance(struct FLinkedAnimGraphReference& Node);
|
|
class UAnimInstance* GetLinkedAnimInstance(struct FLinkedAnimGraphReference& Node);
|
|
void ConvertToLinkedAnimGraphPure(struct FAnimNodeReference& Node, struct FLinkedAnimGraphReference* LinkedAnimGraph, bool* Result);
|
|
struct FLinkedAnimGraphReference ConvertToLinkedAnimGraph(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result);
|
|
};
|
|
|
|
// 0x80 (0xA8 - 0x28)
|
|
// Class AnimGraphRuntime.PlayMontageCallbackProxy
|
|
class UPlayMontageCallbackProxy : public UObject
|
|
{
|
|
public:
|
|
FMulticastInlineDelegateProperty_ OnCompleted; // 0x28(0x10)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
FMulticastInlineDelegateProperty_ OnBlendOut; // 0x38(0x10)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
FMulticastInlineDelegateProperty_ OnInterrupted; // 0x48(0x10)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
FMulticastInlineDelegateProperty_ OnNotifyBegin; // 0x58(0x10)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
FMulticastInlineDelegateProperty_ OnNotifyEnd; // 0x68(0x10)(ZeroConstructor, InstancedReference, BlueprintAssignable, NativeAccessSpecifierPublic)
|
|
uint8 Pad_221E[0x30]; // Fixing Size Of Struct [ Dumper-7 ]
|
|
|
|
static class UClass* StaticClass();
|
|
static class UPlayMontageCallbackProxy* GetDefaultObj();
|
|
|
|
void OnNotifyEndReceived(class FName NotifyName, struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
|
|
void OnNotifyBeginReceived(class FName NotifyName, struct FBranchingPointNotifyPayload& BranchingPointNotifyPayload);
|
|
void OnMontageEnded(class UAnimMontage* Montage, bool bInterrupted);
|
|
void OnMontageBlendingOut(class UAnimMontage* Montage, bool bInterrupted);
|
|
class UPlayMontageCallbackProxy* CreateProxyObjectForPlayMontage(class USkeletalMeshComponent* InSkeletalMeshComponent, class UAnimMontage* MontageToPlay, float PlayRate, float StartingPosition, class FName StartingSection);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.SequenceEvaluatorLibrary
|
|
class USequenceEvaluatorLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class USequenceEvaluatorLibrary* GetDefaultObj();
|
|
|
|
struct FSequenceEvaluatorReference SetSequenceWithInertialBlending(struct FAnimUpdateContext& UpdateContext, struct FSequenceEvaluatorReference& SequenceEvaluator, class UAnimSequenceBase* Sequence, float BlendTime);
|
|
struct FSequenceEvaluatorReference SetSequence(struct FSequenceEvaluatorReference& SequenceEvaluator, class UAnimSequenceBase* Sequence);
|
|
struct FSequenceEvaluatorReference SetExplicitTime(struct FSequenceEvaluatorReference& SequenceEvaluator, float Time);
|
|
class UAnimSequenceBase* GetSequence(struct FSequenceEvaluatorReference& SequenceEvaluator);
|
|
float GetAccumulatedTime(struct FSequenceEvaluatorReference& SequenceEvaluator);
|
|
void ConvertToSequenceEvaluatorPure(struct FAnimNodeReference& Node, struct FSequenceEvaluatorReference* SequenceEvaluator, bool* Result);
|
|
struct FSequenceEvaluatorReference ConvertToSequenceEvaluator(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result);
|
|
struct FSequenceEvaluatorReference AdvanceTime(struct FAnimUpdateContext& UpdateContext, struct FSequenceEvaluatorReference& SequenceEvaluator, float PlayRate);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.SequencePlayerLibrary
|
|
class USequencePlayerLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class USequencePlayerLibrary* GetDefaultObj();
|
|
|
|
struct FSequencePlayerReference SetStartPosition(struct FSequencePlayerReference& SequencePlayer, float StartPosition);
|
|
struct FSequencePlayerReference SetSequenceWithInertialBlending(struct FAnimUpdateContext& UpdateContext, struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase* Sequence, float BlendTime);
|
|
struct FSequencePlayerReference SetSequence(struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase* Sequence);
|
|
struct FSequencePlayerReference SetPlayRate(struct FSequencePlayerReference& SequencePlayer, float PlayRate);
|
|
struct FSequencePlayerReference SetAccumulatedTime(struct FSequencePlayerReference& SequencePlayer, float Time);
|
|
float GetStartPosition(struct FSequencePlayerReference& SequencePlayer);
|
|
class UAnimSequenceBase* GetSequencePure(struct FSequencePlayerReference& SequencePlayer);
|
|
struct FSequencePlayerReference GetSequence(struct FSequencePlayerReference& SequencePlayer, class UAnimSequenceBase*& SequenceBase);
|
|
float GetPlayRate(struct FSequencePlayerReference& SequencePlayer);
|
|
bool GetLoopAnimation(struct FSequencePlayerReference& SequencePlayer);
|
|
float GetAccumulatedTime(struct FSequencePlayerReference& SequencePlayer);
|
|
void ConvertToSequencePlayerPure(struct FAnimNodeReference& Node, struct FSequencePlayerReference* SequencePlayer, bool* Result);
|
|
struct FSequencePlayerReference ConvertToSequencePlayer(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result);
|
|
float ComputePlayRateFromDuration(struct FSequencePlayerReference& SequencePlayer, float Duration);
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.SequencerAnimationSupport
|
|
class ISequencerAnimationSupport : public IInterface
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class ISequencerAnimationSupport* GetDefaultObj();
|
|
|
|
};
|
|
|
|
// 0x0 (0x28 - 0x28)
|
|
// Class AnimGraphRuntime.SkeletalControlLibrary
|
|
class USkeletalControlLibrary : public UBlueprintFunctionLibrary
|
|
{
|
|
public:
|
|
|
|
static class UClass* StaticClass();
|
|
static class USkeletalControlLibrary* GetDefaultObj();
|
|
|
|
struct FSkeletalControlReference SetAlpha(struct FSkeletalControlReference& SkeletalControl, float Alpha);
|
|
float GetAlpha(struct FSkeletalControlReference& SkeletalControl);
|
|
void ConvertToSkeletalControlPure(struct FAnimNodeReference& Node, struct FSkeletalControlReference* SkeletalControl, bool* Result);
|
|
struct FSkeletalControlReference ConvertToSkeletalControl(struct FAnimNodeReference& Node, enum class EAnimNodeReferenceConversionResult* Result);
|
|
};
|
|
|
|
}
|
|
|
|
|