feat: Misc additions.

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

@@ -112,5 +112,18 @@ namespace RE
 			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/BGSLOSData.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/N/NiRefObject.h"
+
+namespace RE
+{
+	class __declspec(novtable) BGSLOSData :
+		public NiRefObject  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BGSLOSData };
+		static constexpr auto VTABLE{ VTABLE::BGSLOSData };
+
+		// members
+		std::uint8_t*  losData;              // 10
+		std::uint16_t* quadGridOffsetArray;  // 18
+		std::uint32_t  losDataSize;          // 20
+		std::uint16_t  indexCount;           // 24
+	};
+	static_assert(sizeof(BGSLOSData) == 0x28);
+}

include/RE/B/BGSLocAlias.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "RE/B/BGSBaseAlias.h"
+
+namespace RE
+{
+	class BGSKeyword;
+	class BGSLocation;
+	class TESCondition;
+	class TESQuest;
+
+	class __declspec(novtable) BGSLocAlias :
+		public BGSBaseAlias  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BGSLocAlias };
+		static constexpr auto VTABLE{ VTABLE::BGSLocAlias };
+
+		// members
+		BGSLocation*  forcedLoc;              // 28
+		BGSKeyword*   forcedFromAliasFilter;  // 30
+		TESQuest*     externalQuest;          // 38
+		TESCondition* conditions;             // 40
+		std::uint32_t forcedFromAlias;        // 48
+		std::uint32_t forcedFromEvent;        // 4C
+		std::uint32_t forcedEventData;        // 50
+		std::uint32_t externalAlias;          // 54
+		std::uint32_t closestToAlias;         // 58
+	};
+	static_assert(sizeof(BGSLocAlias) == 0x60);
+}

include/RE/B/BGSQuestObjective.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BGSLocalizedString.h"
+
+namespace RE
+{
+	class TESQuest;
+	class TESQuestTarget;
+
+	class BGSQuestObjective
+	{
+	public:
+		// members
+		BGSLocalizedString displayText;  // 00
+		TESQuest*          ownerQuest;   // 08
+		TESQuestTarget**   targets;      // 10
+		std::uint32_t      numTargets;   // 18
+		std::uint16_t      index;        // 1C
+		bool               initialized;  // 1E
+		char               state;        // 1F
+		std::uint32_t      flags;        // 20
+	};
+	static_assert(sizeof(BGSQuestObjective) == 0x28);
+}

include/RE/B/BGSTerminal.h

@@ -30,6 +30,16 @@ namespace RE
 		class MenuItem
 		{
 		public:
+			enum class Flag
+			{
+				kBackToTop = 0x0,
+				kRedraw = 0x1,
+				kSubmenu = 0x2,
+				kText = 0x3,
+				kImage = 0x4,
+				kHolotape = 0x5
+			};
+
 			union USelectionResult
 			{
 				BGSTerminal*        subMenu;
@@ -40,12 +50,12 @@ namespace RE
 			static_assert(sizeof(USelectionResult) == 0x8);
 
 			// members
-			BGSLocalizedString itemText;         // 00
-			BGSLocalizedString responseText;     // 08
-			USelectionResult   selectionResult;  // 10
-			TESCondition       conditions;       // 18
-			std::uint16_t      id;               // 20
-			std::int8_t        flags;            // 22
+			BGSLocalizedString              itemText;         // 00
+			BGSLocalizedString              responseText;     // 08
+			USelectionResult                selectionResult;  // 10
+			TESCondition                    conditions;       // 18
+			std::uint16_t                   id;               // 20
+			REX::EnumSet<Flag, std::int8_t> flags;            // 22
 		};
 		static_assert(sizeof(MenuItem) == 0x28);
 

include/RE/B/BSIMusicTrack.h

@@ -8,7 +8,14 @@ namespace RE
 		static constexpr auto RTTI{ RTTI::BSIMusicTrack };
 		static constexpr auto VTABLE{ VTABLE::BSIMusicTrack };
 
-		enum class MUSIC_STATUS;
+		enum class MUSIC_STATUS
+		{
+			kInactive = 0x0,
+			kPlaying = 0x1,
+			kPaused = 0x2,
+			kFinishing = 0x3,
+			kFinished = 0x4
+		};
 
 		virtual ~BSIMusicTrack() = default;  // 00
 

include/RE/B/BSPathingGoal.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/B/BSPathingLocation.h"
+#include "RE/N/NiPoint.h"
+
+namespace RE
+{
+	class BSPathingGoal
+	{
+	public:
+		enum class GOAL_RADIUS_TYPE
+		{
+			kNone = 0x0,
+			kSoft = 0x1,
+			kHard = 0x2,
+			kMask = 0x3
+		};
+
+		enum class GOAL_HEIGHT_TYPE
+		{
+			kNone = 0x0,
+			kFixed = 0x10,
+			kMask = 0x10
+		};
+
+		// members
+		NiPoint3          targetPoint;            // 00
+		float             targetAngleTolerance;   // 0C
+		BSPathingLocation location;               // 10
+		float             zDelta;                 // 40
+		float             goalRadius;             // 44
+		float             normalizedSpeedAtGoal;  // 48
+	};
+	static_assert(sizeof(BSPathingGoal) == 0x50);
+}

include/RE/B/BSPathingLocation.h

@@ -7,7 +7,6 @@
 namespace RE
 {
 	class BSNavmeshInfo;
-	class BSPatchingCell;
 
 	class BSPathingLocation
 	{

include/RE/B/BSPathingStart.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RE/B/BSPathingLocation.h"
+
+namespace RE
+{
+	class BSPathingStart
+	{
+	public:
+		enum class START_TANGENT_TYPE
+		{
+			kNone = 0x0,
+			kSet = 0x1,
+			kKeep = 0x2,
+			kMask = 0x3
+		};
+
+		enum class FLAGS
+		{
+			kSelected = 0x0,
+			kStartsMoving = 0x1
+		};
+
+		// members
+		BSPathingLocation location;  // 00
+		float             tangent;   // 30
+	};
+	static_assert(sizeof(BSPathingStart) == 0x38);
+}

include/RE/B/BSRandom.h

@@ -24,5 +24,12 @@ namespace RE
 			static REL::Relocation<func_t> func{ ID::BSRandom::Float0To1 };
 			return func();
 		}
+
+		inline std::int32_t Int(std::int32_t a_min, std::int32_t a_max)
+		{
+			using func_t = decltype(&BSRandom::Int);
+			static REL::Relocation<func_t> func{ ID::BSRandom::Int };
+			return func(a_min, a_max);
+		}
 	}
 }

include/RE/B/BSUtilities.h

@@ -4,29 +4,37 @@
 
 namespace RE
 {
+	class BSFlattenedBoneTree;
 	class NiAVObject;
 
 	namespace BSUtilities
 	{
 		inline std::uint16_t ConvertFloatToHalf(float a_value)
 		{
-			using func_t = decltype(&ConvertFloatToHalf);
+			using func_t = decltype(&BSUtilities::ConvertFloatToHalf);
 			static REL::Relocation<func_t> func{ ID::BSUtilities::ConvertFloatToHalf };
 			return func(a_value);
 		}
 
 		inline float ConvertHalfToFloat(std::uint16_t a_value)
 		{
-			using func_t = decltype(&ConvertHalfToFloat);
+			using func_t = decltype(&BSUtilities::ConvertHalfToFloat);
 			static REL::Relocation<func_t> func{ ID::BSUtilities::ConvertHalfToFloat };
 			return func(a_value);
 		}
 
 		inline NiAVObject* GetObjectByName(NiAVObject* a_root, const BSFixedString& a_name, bool a_tryInternal, bool a_dontAttach)
 		{
-			using func_t = decltype(&GetObjectByName);
+			using func_t = decltype(&BSUtilities::GetObjectByName);
 			static REL::Relocation<func_t> func{ ID::BSUtilities::GetObjectByName };
 			return func(a_root, a_name, a_tryInternal, a_dontAttach);
 		}
+
+		inline BSFlattenedBoneTree* GetFlattenedBoneTree(NiAVObject* a_root)
+		{
+			using func_t = decltype(&BSUtilities::GetFlattenedBoneTree);
+			static REL::Relocation<func_t> func{ ID::BSUtilities::GetFlattenedBoneTree };
+			return func(a_root);
+		}
 	}
 }

include/RE/B/BaseTreeData.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BoneData.h"
+#include "RE/N/NiMatrix3.h"
+
+namespace RE
+{
+	class BaseTreeData :
+		public BSIntrusiveRefCounted  // 00
+	{
+	public:
+		// members
+		BSTArray<BoneData>  branchBoneData;            // 08
+		BSTArray<NiMatrix3> parentWorldBoneRotations;  // 20
+	};
+	static_assert(sizeof(BaseTreeData) == 0x38);
+}