feat: bunch of misc RE

include/RE/A/ACTOR_MOVEMENT_TYPE.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_MOVEMENT_TYPE : std::uint32_t
+	{
+		kWalk = 0x0,
+		kRun = 0x1,
+		kSneak = 0x2,
+		kBleedout = 0x3,
+		kSwim = 0x4
+	};
+}

include/RE/A/AIProcess.h

@@ -35,6 +35,17 @@ namespace RE
 			kOutDelete = 0x6
 		};
 
+		enum class HEAD_TRACK_TYPE
+		{
+			kDefault = 0x0,
+			kAction = 0x1,
+			kCombat = 0x2,
+			kDialog = 0x3,
+			kScript = 0x4,
+			kProcedure = 0x5,
+			kTotal = 0x6
+		};
+
 		[[nodiscard]] TESAmmo* GetCurrentAmmo(BGSEquipIndex a_equipIndex) const
 		{
 			using func_t = decltype(&AIProcess::GetCurrentAmmo);

include/RE/A/ActionOutput.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class TESIdleForm;
+
+	class ActionOutput
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ActionOutput };
+
+		enum class ACTION_RESULTS : std::uint32_t
+		{
+			kNotAllowed = 0xFFFFFFFF
+		};
+
+		// members
+		BSFixedString      animEvent;        // 00
+		BSFixedString      targetAnimEvent;  // 08
+		std::int32_t       result;           // 10
+		TESIdleForm*       sequence;         // 18
+		const TESIdleForm* animObjIdle;      // 20
+		std::uint32_t      sequenceIndex;    // 28;
+	};
+	static_assert(sizeof(ActionOutput) == 0x30);
+}

include/RE/A/ActionPoints.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace RE
+{
+	class ActionPoints
+	{
+	public:
+		enum class Action
+		{
+			kUnarmed = 0x0,
+			kOneHandMelee = 0x1,
+			kTwoHandMelee = 0x2,
+			kMagic = 0x3,
+			kRanged = 0x4,
+			kReload = 0x5,
+			kSwitchWeapon = 0x6,
+			kToggleWeaponDrawn = 0x7,
+			kHeal = 0x8,
+			kPlayerVATSDeath = 0x9,
+			kPlayerDialogue = 0xA,
+			kSightedEnter = 0xB,
+
+			kTotal = 0xC
+		};
+	};
+	static_assert(std::is_empty_v<ActionPoints>);
+}

include/RE/A/Actor.h

@@ -124,16 +124,6 @@ namespace RE
 			kUnderwater = 1 << 31,
 		};
 
-		enum class DETECTION_PRIORITY
-		{
-			kNone = 0x0,
-			kVeryLow = 0x1,
-			kLow = 0x2,
-			kNormal = 0x3,
-			kHigh = 0x4,
-			kCritical = 0x5,
-		};
-
 		// add
 		virtual void                 PlayPickUpSound(TESBoundObject* a_boundObj, bool a_pickUp, bool a_use);                                                                                                             // 0C6
 		virtual float                GetHeading() const { return data.angle.z; }                                                                                                                                         // 0C7

include/RE/A/ActorEquipManager.h

@@ -19,6 +19,18 @@ namespace RE
 		public BSTEventSource<ActorEquipManagerEvent::Event>  // 08
 	{
 	public:
+		enum class CanEquipResult
+		{
+			kSuccess = 0x0,
+			kInvalidItem = 0x1,
+			kNoModEquip = 0x2,
+			kPAWhileNotInPA = 0x3,
+			kNonPAWhileInPA = 0x4,
+			kEquipStateLocked = 0x5,
+			kItemBroken = 0x6,
+			kNoEquipKeyword = 0x7
+		};
+
 		[[nodiscard]] static ActorEquipManager* GetSingleton()
 		{
 			static REL::Relocation<ActorEquipManager**> singleton{ ID::ActorEquipManager::Singleton };

include/RE/A/ActorMotionFeedbackData.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/N/NiPoint.h"
+
+namespace RE
+{
+	class ActorMotionFeedbackData
+	{
+	public:
+		// members
+		NiPoint3 desiredWorldDelta;  // 00
+		NiPoint3 actualWorldDelta;   // 0C
+		float    previousSpeed;      // 18
+		float    previousDirection;  // 1C
+		float    currentHeading;     // 20
+	};
+	static_assert(sizeof(ActorMotionFeedbackData) == 0x24);
+}

include/RE/A/ActorStance.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	class ActorStance
+	{
+	public:
+		// members
+		std::uint8_t stance;          // 00
+		std::uint8_t stanceModifier;  // 01
+		bool         mirrored;        // 02
+	};
+	static_assert(sizeof(ActorStance) == 0x03);
+}

include/RE/A/ActorState.h

@@ -25,6 +25,7 @@ namespace RE
 		virtual void            SetReloadingImpl(bool a_reloading);               // 26
 
 		[[nodiscard]] bool GetWeaponMagicDrawn() const noexcept { return weaponState >= WEAPON_STATE::kDrawn; }
+		[[nodiscard]] bool IsSwimming() const noexcept { return DoGetMoveModeBits(0x400); }
 
 		// members
 		std::uint32_t     moveMode: 14;            // 08:00
@@ -49,6 +50,9 @@ namespace RE
 		INTERACTING_STATE interactingState: 2;     // 0C:18
 		std::uint32_t     headTrackRotation: 1;    // 0C:20
 		std::uint32_t     inSyncAnim: 1;           // 0C:21
+
+	private:
+		bool DoGetMoveModeBits(std::uint16_t a_bits) const { return (a_bits & moveMode & 0x3FFF) == a_bits; }
 	};
 	static_assert(sizeof(ActorState) == 0x10);
 }

include/RE/A/AvoidAreaStruct.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSPathingAvoidNode.h"
+
+namespace RE
+{
+	class TESObjectREFR;
+
+	class AvoidAreaStruct
+	{
+	public:
+		// members
+		BSPathingAvoidNode avoideNode;  // 00
+		float              timeExpire;  // 24
+		TESObjectREFR*     refObj;      // 28
+		AvoidAreaStruct*   next;        // 30
+	};
+	static_assert(sizeof(AvoidAreaStruct) == 0x38);
+}

include/RE/B/BGSAwakeSoundData.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BSSoundHandle.h"
+
+namespace RE
+{
+	class BGSAwakeSoundData
+	{
+	public:
+		enum class eState : std::uint32_t
+		{
+			kPlaying = 0x0,
+			kPaused = 0x1,
+			kStopped = 0x2,
+
+			kTotal = 0x3
+		};
+
+		BSSoundHandle             sound;        // 00
+		std::uint32_t             soundFormID;  // 08
+		float                     volume;       // 0C
+		BGSAwakeSoundData::eState state;        // 10
+	};
+	static_assert(sizeof(BGSAwakeSoundData) == 0x14);
+}

include/RE/B/BGSCameraShot.h

@@ -44,6 +44,13 @@ namespace RE
 			kDialogue = 0x2
 		};
 
+		enum class CAM_ZOOM
+		{
+			kDefault = 0x0,
+			kDisable = 0x1,
+			kShotList = 0x2
+		};
+
 		class CAMERA_SHOT_DATA
 		{
 		public:

include/RE/B/BGSCharacterMorph.h

@@ -96,5 +96,21 @@ namespace RE
 			std::uint16_t           presetMaskID;  // 38
 		};
 		static_assert(sizeof(Group) == 0x40);
+
+		enum class WeightComponent : std::uint32_t
+		{
+			kThin = 0x0,
+			kMuscular = 0x1,
+			kFat = 0x2
+		};
+
+		enum class BODY_MORPH_REGION : std::uint32_t
+		{
+			kHead = 0x0,
+			kUpperTorso = 0x1,
+			kArms = 0x2,
+			kLowerTorso = 0x3,
+			kLegs = 0x4
+		};
 	}
 }

include/RE/B/BGSDecalNode.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/N/NiNode.h"
+
+namespace RE
+{
+	class BSTempEffect;
+
+	class __declspec(novtable) BGSDecalNode :
+		public NiNode  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BGSDecalNode };
+		static constexpr auto VTABLE{ VTABLE::BGSDecalNode };
+		static constexpr auto Ni_RTTI{ Ni_RTTI::BGSDecalNode };
+
+		// members
+		BSTArray<NiPointer<BSTempEffect>> decals;               // 140
+		BSTArray<std::uint32_t>           decalCreationFrames;  // 158
+		bool                              skinnedNode;          // 170
+	};
+	static_assert(sizeof(BGSDecalNode) == 0x180);
+}

include/RE/B/BGSDialogueBranch.h

@@ -14,6 +14,13 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::BGSDialogueBranch };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kDLBR };
 
+		enum class Flag
+		{
+			kTopLevel = 0x0,
+			kBlocking = 0x1,
+			kExclusive = 0x2
+		};
+
 		// members
 		std::uint32_t                             flags;          // 20
 		TESQuest*                                 quest;          // 28

include/RE/B/BGSDirectionalAmbientLightingColors.h

@@ -5,6 +5,19 @@ namespace RE
 	class BGSDirectionalAmbientLightingColors
 	{
 	public:
+		enum class ColorIndex : std::uint32_t
+		{
+			kXPos = 0x0,
+			kXNeg = 0x1,
+			kYPos = 0x2,
+			kYNeg = 0x3,
+			kZPos = 0x4,
+			kZNeg = 0x5,
+			kAxisCount = 0x6,
+			kSpecularTint = 0x6,
+			kColorCount = 0x7
+		};
+
 		// members
 		std::uint32_t colorValues[7];  // 00
 		float         fresnelPower;    // 1C

include/RE/B/BGSExplosion.h

@@ -23,6 +23,20 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::BGSExplosion };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kEXPL };
 
+		enum class EXPLOSION_TYPE
+		{
+			kNormal = 0x0,
+			kChain = 0x1
+		};
+
+		enum class KnockDownMode
+		{
+			kNever = 0x0,
+			kAlways = 0x1,
+			kFormula = 0x2,
+			kNPC = 0x3
+		};
+
 		// members
 		BGSExplosionData data;  // 0D8
 	};

include/RE/B/BGSHeadPart.h

@@ -45,6 +45,13 @@ namespace RE
 			kHeadRear = 0x9
 		};
 
+		enum class MorphIndex
+		{
+			kRaceMorph = 0x0,
+			kDefaultMorph = 0x1,
+			kChargenMorph = 0x2
+		};
+
 		[[nodiscard]] bool IsExtraPart() const noexcept { return flags.all(Flag::kExtraPart); }
 
 		// members

include/RE/B/BGSMessage.h

@@ -21,6 +21,12 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::BGSMessage };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kMESG };
 
+		enum class MessageFlag
+		{
+			kMessageBox = 0x0,
+			kInitialDelay = 0x1
+		};
+
 		void AddButton(MESSAGEBOX_BUTTON* btn)
 		{
 			using func_t = decltype(&BGSMessage::AddButton);

include/RE/B/BGSProjectile.h

@@ -23,6 +23,33 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::BGSProjectile };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kPROJ };
 
+		enum class BGSProjectileFlags
+		{
+			kHitscan = 0x1,
+			kExplosion = 0x2,
+			kExplosionAltTrigger = 0x4,
+			kMuzzleFlash = 0x8,
+			kBounceOnImpact = 0x10,
+			kCanTurnOff = 0x20,
+			kCanPickup = 0x40,
+			kSupersonic = 0x80,
+			kPinsLimbs = 0x100,
+			kPassSMTransparent = 0x200,
+			kDisableCombatAimCorrection = 0x400,
+			kPenetratesGeometry = 0x800,
+			kContinuousUpdate = 0x1000,
+			kSeeksTarget = 0x2000,
+			kFirstMotionBit = 0x10,
+			kMotionMissile = 0x10000,
+			kMotionGrenade = 0x20000,
+			kMotionBeam = 0x40000,
+			kMotionFlamethrower = 0x80000,
+			kMotionCone = 0x100000,
+			kMotionBarrier = 0x200000,
+			kMotionArrow = 0x400000,
+			kMotionTypes = 0x7F0000
+		};
+
 		bool CollidesWithSmallTransparentLayer()
 		{
 			using func_t = decltype(&BGSProjectile::CollidesWithSmallTransparentLayer);