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/BGSAssociationType.h

@@ -13,9 +13,21 @@ namespace RE
 		static constexpr auto VTABLE{ VTABLE::BGSAssociationType };
 		static constexpr auto FORM_ID{ ENUM_FORM_ID::kASTP };
 
+		enum class Member
+		{
+			kParent = 0x0,
+			kChild = 0x1,
+			kCount = 0x2
+		};
+
+		enum class Flags
+		{
+			kFamily = 0x1
+		};
+
 		// members
-		BSFixedStringCS associationLabel[2][2];  // 20
-		std::uint32_t   flags;                   // 40
+		BSFixedStringCS                    associationLabel[2][2];  // 20
+		REX::EnumSet<Flags, std::uint32_t> flags;                   // 40
 	};
 	static_assert(sizeof(BGSAssociationType) == 0x48);
 }

include/RE/B/BGSAwakeSoundData.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BSSoundHandle.h"
+
+namespace RE
+{
+	class BGSAwakeSoundData
+	{
+	public:
+		enum class State : std::uint32_t
+		{
+			kPlaying = 0x0,
+			kPaused = 0x1,
+			kStopped = 0x2,
+
+			kTotal = 0x3
+		};
+
+		BSSoundHandle            sound;        // 00
+		std::uint32_t            soundFormID;  // 08
+		float                    volume;       // 0C
+		BGSAwakeSoundData::State 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,34 @@ 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
+		};
+
+		enum class Axis : std::uint32_t
+		{
+			kPosX = 0x0,
+			kPosY = 0x1,
+			kPosZ = 0x2,
+			kRotX = 0x3,
+			kRotY = 0x4,
+			kRotZ = 0x5,
+			kScaleX = 0x6,
+			kScaleY = 0x7,
+			kScaleZ = 0x8
+		};
 	}
 }

include/RE/B/BGSConstructibleObject.h

@@ -33,6 +33,13 @@ namespace RE
 		[[nodiscard]] TESForm*      GetCreatedItem() const noexcept { return createdItem; }
 		[[nodiscard]] std::uint16_t GetWorkshopPriority() const noexcept { return data.workshopPriority; }
 
+		bool PlayerPassesConditions()
+		{
+			using func_t = decltype(&BGSConstructibleObject::PlayerPassesConditions);
+			static REL::Relocation<func_t> func{ ID::BGSConstructibleObject::PlayerPassesConditions };
+			return func(this);
+		}
+
 		// members
 		BSTArray<BSTTuple<TESForm*, BGSTypedFormValuePair::SharedVal>>* requiredItems;   // 50
 		TESCondition                                                    conditions;      // 58

include/RE/B/BGSDecalEmitter.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class BGSImpactData;
+	class BSTempEffectParticle;
+
+	class BGSDecalEmitter
+	{
+	public:
+		// members
+		std::int32_t                    decalsToEmit;     // 00
+		bool                            finished;         // 04
+		BGSImpactData*                  decalImpactData;  // 08
+		NiPointer<BSTempEffectParticle> particleData;     // 10
+	};
+	static_assert(sizeof(BGSDecalEmitter) == 0x18);
+}

include/RE/B/BGSDecalGroup.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class DECAL_CREATION_DATA;
+
+	class BGSDecalGroup
+	{
+	public:
+		// members
+		bool                           permanentGroup;  // 00
+		bool                           manualSaveLoad;  // 01
+		BSTArray<std::uint32_t>        decalGroup;      // 08
+		BSTArray<DECAL_CREATION_DATA*> pendingDecals;   // 20
+	};
+	static_assert(sizeof(BGSDecalGroup) == 0x38);
+}

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