Merge pull request #10 from qudix/dev/ue

feat: lots of `UE`

Author: shad0wshayd3

include/UE/A/AActor.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include "UE/A/APawn.h"
+#include "UE/E/EMovementMode.h"
+#include "UE/F/FBasedMovementInfo.h"
+#include "UE/F/FRepRootMotionMontage.h"
+#include "UE/F/FRootMotionSourceGroup.h"
+#include "UE/F/FRootMotionMovementParams.h"
+#include "UE/T/TQuat.h"
+
+namespace UE
+{
+	class ACharacter;
+	class FHitResult;
+	class FSimulatedRootMotionReplicatedMove;
+	class UCapsuleComponent;
+	class UCharacterMovementComponent;
+	class USkeletalMeshComponent;
+
+	using FCharacterReachedApexSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void>;
+	using FLandedSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, const FHitResult&>;
+	using FMovementModeChangedSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, ACharacter*, EMovementMode, std::uint8_t>;
+	using FCharacterMovementUpdatedSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, float, FVector, FVector>;
+
+	class ACharacter :
+		public APawn
+	{
+	public:
+		UE_DEFINE_OBJECT("/Script/Engine", "Character");
+
+		// override
+		virtual ~ACharacter();  // 00
+
+		// members
+		TObjectPtr<USkeletalMeshComponent>         mesh;                                          // 320
+		TObjectPtr<UCharacterMovementComponent>    characterMovement;                             // 328
+		TObjectPtr<UCapsuleComponent>              capsuleComponent;                              // 330
+		FBasedMovementInfo                         basedMovement;                                 // 338
+		FBasedMovementInfo                         replicatedBasedMovement;                       // 388
+		float                                      animRootMotionTranslationScale;                // 3D8
+		FVector                                    baseTranslationOffset;                         // 3E0
+		FQuat                                      baseRotationOffset;                            // 400
+		float                                      replicatedServerLastTransformUpdateTimeStamp;  // 420
+		float                                      replayLastTransformUpdateTimeStamp;            // 424
+		std::uint8_t                               replicatedMovementMode;                        // 428
+		FVector_NetQuantizeNormal                  replicatedGravityDirection;                    // 430
+		bool                                       inBaseReplication;                             // 448
+		FVector_NetQuantizeNormal                  preNetReceivedGravityDirection;                // 450
+		float                                      crouchedEyeHeight;                             // 468
+		std::uint32_t                              isCrouched: 1;                                 // 46C:0
+		std::uint32_t                              proxyIsJumpForceApplied: 1;                    // 46C:1
+		std::uint32_t                              pressedJump: 1;                                // 46C:2
+		std::uint32_t                              clientUpdating: 1;                             // 46C:3
+		std::uint32_t                              clientWasFalling: 1;                           // 46C:4
+		std::uint32_t                              clientResimulateRootMotion: 1;                 // 46C:5
+		std::uint32_t                              clientResimulateRootMotionSources: 1;          // 46C:6
+		std::uint32_t                              simGravityDisabled: 1;                         // 46C:7
+		std::uint32_t                              clientCheckEncroachmentOnNetUpdate: 1;         // 46D:0
+		std::uint32_t                              serverMoveIgnoreRootMotion: 1;                 // 46D:1
+		std::uint32_t                              wasJumping: 1;                                 // 46D:2
+		float                                      jumpKeyHoldTime;                               // 470
+		float                                      jumpForceTimeRemaining;                        // 474
+		float                                      proxyJumpForceStartedTime;                     // 478
+		float                                      jumpMaxHoldTime;                               // 47C
+		std::int32_t                               jumpMaxCount;                                  // 480
+		std::int32_t                               jumpCurrentCount;                              // 484
+		std::int32_t                               jumpCurrentCountPreJump;                       // 488
+		std::uint32_t                              numActorOverlapEventsCounter;                  // 48C
+		FCharacterReachedApexSignature             onReachedJumpApex;                             // 490
+		FLandedSignature                           landedDelegate;                                // 4A0
+		FMovementModeChangedSignature              movementModeChangedDelegate;                   // 4B0
+		FCharacterMovementUpdatedSignature         onCharacterMovementUpdated;                    // 4C0
+		FRootMotionSourceGroup                     savedRootMotion;                               // 4D0
+		FRootMotionMovementParams                  clientRootMotionParams;                        // 520
+		TArray<FSimulatedRootMotionReplicatedMove> rootMotionRepMoves;                            // 590
+		FRepRootMotionMontage                      repRootMotion;                                 // 5A0
+	};
+	static_assert(sizeof(ACharacter) == 0x680);
+}

include/UE/A/ACharacter.h

@@ -0,0 +1,48 @@
+#pragma once
+
+#include "UE/A/AActor.h"
+#include "UE/I/INavAgentInterface.h"
+#include "UE/T/TBaseDynamicMulticastDelegate.h"
+#include "UE/T/TMulticastDelegate.h"
+
+namespace UE
+{
+	class ACharacter;
+	class APawn;
+	class APlayerState;
+	class UDamageType;
+
+	using FInstigatedAnyDamageSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, float, const UDamageType*, AActor*, AActor*>;
+	using FOnPossessedPawnChanged = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, APawn*, APawn*>;
+	using FPawnChangedSignature = TMulticastDelegate<void(APawn*)>;
+
+	class AController :
+		public AActor,
+		public INavAgentInterface
+	{
+	public:
+		UE_DEFINE_OBJECT("/Script/Engine", "Controller");
+
+		// override
+		virtual ~AController();
+
+		// members
+		TObjectPtr<APlayerState>      playerState;                    // 2A0
+		TWeakObjectPtr<AActor>        startSpot;                      // 2A8
+		FInstigatedAnyDamageSignature onInstigatedAnyDamage;          // 2B0
+		FOnPossessedPawnChanged       onPossessedPawnChanged;         // 2C0
+		FName                         stateName;                      // 2D0
+		TObjectPtr<APawn>             pawn;                           // 2D8
+		TWeakObjectPtr<APawn>         oldPawn;                        // 2E0
+		TObjectPtr<ACharacter>        character;                      // 2E8
+		TObjectPtr<USceneComponent>   transformComponent;             // 2F0
+		FPawnChangedSignature         onNewPawn;                      // 2F8
+		FRotator                      controlRotation;                // 310
+		std::uint8_t                  attachToPawn: 1;                // 328:0
+		std::uint8_t                  isPlayerController: 1;          // 328:1
+		std::uint8_t                  canPossessWithoutAuthority: 1;  // 328:2
+		std::uint8_t                  ignoreMoveInput;                // 329
+		std::uint8_t                  ignoreLookInput;                // 330
+	};
+	static_assert(sizeof(AController) == 0x330);
+}

include/UE/A/AController.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include "UE/A/AActor.h"
+#include "UE/E/EAutoPossessAI.h"
+#include "UE/E/EAutoReceiveInput.h"
+#include "UE/I/INavAgentInterface.h"
+#include "UE/T/TBaseDynamicMulticastDelegate.h"
+#include "UE/T/TSparseDynamicDelegate.h"
+#include "UE/T/TSubclassOf.h"
+
+namespace UE
+{
+	class AController;
+	class APlayerState;
+	class FPawnControllerChangedSignatureInfoGetter;
+	class FPawnRestartedSignatureInfoGetter;
+
+	using FPawnControllerChangedSignature_MCSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, APawn*, AController*, AController*>;
+	using FPawnControllerChangedSignature = TSparseDynamicDelegate<FPawnControllerChangedSignature_MCSignature, APawn, FPawnControllerChangedSignatureInfoGetter>;
+	using FPawnRestartedSignature_MCSignature = TBaseDynamicMulticastDelegate<FNotThreadSafeDelegateMode, void, APawn*>;
+	using FPawnRestartedSignature = TSparseDynamicDelegate<FPawnRestartedSignature_MCSignature, APawn, FPawnRestartedSignatureInfoGetter>;
+
+	class APawn :
+		public AActor,
+		public INavAgentInterface
+	{
+	public:
+		UE_DEFINE_OBJECT("/Script/Engine", "Pawn");
+
+		// override
+		virtual ~APawn();
+
+		// members
+		std::uint32_t                   useControllerRotationPitch: 1;     // 2A0:0
+		std::uint32_t                   useControllerRotationYaw: 1;       // 2A0:1
+		std::uint32_t                   useControllerRotationRoll: 1;      // 2A0:2
+		std::uint32_t                   canAffectNavigationGeneration: 1;  // 2A0:3
+		std::uint32_t                   inputEnabled: 1;                   // 2A0:4
+		std::uint32_t                   processingOutsideWorldBounds: 1;   // 2A0:5
+		std::uint32_t                   isLocalViewTarget: 1;              // 2A0:6
+		float                           baseEyeHeight;                     // 2A4
+		TEnumAsByte<EAutoReceiveInput>  autoPossessPlayer;                 // 2A8
+		EAutoPossessAI                  autoPossessAI;                     // 2A9
+		std::uint8_t                    remoteViewPitch;                   // 2AA
+		TSubclassOf<AController>        aiControllerClass;                 // 2B0
+		TObjectPtr<APlayerState>        playerState;                       // 2B8
+		float                           blendedReplayViewPitch;            // 2C0
+		TObjectPtr<AController>         lastHitBy;                         // 2C4
+		TObjectPtr<AController>         controller;                        // 2D0
+		TObjectPtr<AController>         previousController;                // 2D8
+		float                           allowedYawError;                   // 2E0
+		FPawnControllerChangedSignature receiveControllerChangedDelegate;  // 2E4
+		FPawnRestartedSignature         receiveRestartedDelegate;          // 2E5
+		FVector                         controlInputVector;                // 2E8
+		FVector                         lastControlInputVector;            // 300
+		TSubclassOf<UInputComponent>    overrideInputComponentClass;       // 318
+	};
+	static_assert(sizeof(APawn) == 0x320);
+}

include/UE/A/APawn.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "UE/A/AController.h"
+#include "UE/I/IWorldPartitionStreamingSourceProvider.h"
+#include "UE/T/TSubclassOf.h"
+
+namespace UE
+{
+	class AHUD;
+	class APlayerCameraManager;
+	class UCheatManager;
+	class UPlayer;
+	class UPrimitiveComponent;
+
+	class APlayerController :
+		public AController,
+		public IWorldPartitionStreamingSourceProvider
+	{
+	public:
+		UE_DEFINE_OBJECT("/Script/Engine", "PlayerController");
+
+		// override
+		virtual ~APlayerController();
+
+		// members
+		TObjectPtr<UPlayer>                         player;                              // 338
+		TObjectPtr<APawn>                           acknowledgedPawn;                    // 340
+		TObjectPtr<AHUD>                            myHUD;                               // 348
+		TObjectPtr<APlayerCameraManager>            playerCameraManager;                 // 350
+		TSubclassOf<APlayerCameraManager>           playerCameraManagerClass;            // 358
+		bool                                        autoManageActiveCameraTarget;        // 360
+		FRotator                                    targetViewRotation;                  // 368
+		FRotator                                    blendedTargetViewRotation;           // 380
+		float                                       smoothTargetViewRotationSpeed;       // 398
+		float                                       localPlayerCachedLODDistanceFactor;  // 39C
+		TArray<TObjectPtr<AActor>>                  hiddenActors;                        // 3A0
+		TArray<TWeakObjectPtr<UPrimitiveComponent>> hiddenPrimitiveComponents;           // 3B0
+		bool                                        renderPrimitiveComponents;           // 3C0
+		float                                       lastSpectatorStateSynchTime;         // 3C4
+		FVector                                     lastSpectatorSyncLocation;           // 3C8
+		FRotator                                    lastSpectatorSyncRotation;           // 3E0
+		std::int32_t                                clientCap;                           // 3F8
+		TObjectPtr<UCheatManager>                   cheatManager;                        // 400
+																						 // ...
+	};
+	//static_assert(sizeof(APlayerController) == 0x858);
+}

include/UE/A/APlayerController.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace UE
+{
+	enum class EAutoPossessAI : std::uint8_t
+	{
+		Disabled,
+		PlacedInWorld,
+		Spawned,
+		PlacedInWorldOrSpawned,
+	};
+}

include/UE/E/EAutoPossessAI.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace UE
+{
+	enum class EComponentCreationMethod : std::uint8_t
+	{
+		Native,
+		SimpleConstructionScript,
+		UserConstructionScript,
+		Instance,
+	};
+}

include/UE/E/EComponentCreationMethod.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace UE
+{
+	enum class EEulerRotationOrder : std::uint8_t
+	{
+		XYZ = 0u,
+		XZY = 1u,
+		YXZ = 2u,
+		YZX = 3u,
+		ZXY = 4u,
+		ZYX = 5u,
+	};
+}

include/UE/E/EEulerRotationOrder.h

@@ -0,0 +1,78 @@
+#pragma once
+
+namespace UE
+{
+	enum class EFormID : std::uint8_t
+	{
+		NONE = 0,
+		TES4 = 1,
+		GRUP = 2,
+		GMST = 3,
+		GLOB = 4,
+		CLAS = 5,
+		FACT = 6,
+		HAIR = 7,
+		EYES = 8,
+		RACE = 9,
+		SOUN = 10,
+		SKIL = 11,
+		MGEF = 12,
+		SCPT = 13,
+		LTEX = 14,
+		ENCH = 15,
+		SPEL = 16,
+		BSGN = 17,
+		ACTI = 18,
+		APPA = 19,
+		ARMO = 20,
+		BOOK = 21,
+		CLOT = 22,
+		CONT = 23,
+		DOOR = 24,
+		INGR = 25,
+		LIGH = 26,
+		MISC = 27,
+		STAT = 28,
+		GRAS = 29,
+		TREE = 30,
+		FLOR = 31,
+		FURN = 32,
+		WEAP = 33,
+		AMMO = 34,
+		NPC_ = 35,
+		CREA = 36,
+		LVLC = 37,
+		SLGM = 38,
+		KEYM = 39,
+		ALCH = 40,
+		SBSP = 41,
+		SGST = 42,
+		LVLI = 43,
+		SNDG = 44,
+		WTHR = 45,
+		CLMT = 46,
+		REGN = 47,
+		CELL = 48,
+		REFR = 49,
+		ACHR = 50,
+		ACRE = 51,
+		PGRD = 52,
+		WRLD = 53,
+		LAND = 54,
+		TLOD = 55,
+		ROAD = 56,
+		DIAL = 57,
+		INFO = 58,
+		QUST = 59,
+		IDLE = 60,
+		PACK = 61,
+		CSTY = 62,
+		LSCR = 63,
+		LVSP = 64,
+		ANIO = 65,
+		WATR = 66,
+		EFSH = 67,
+		TOFT = 68,
+		LVRG = 69,
+	};
+}

include/UE/E/EFormID.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace UE
+{
+	enum class EMovementMode : std::int32_t
+	{
+		None,
+		Walking,
+		NavWalking,
+		Falling,
+		Swimming,
+		Flying,
+		Custom,
+	};
+}