feat: Misc RE

include/RE/B/BGSCharacterTint.h

@@ -150,14 +150,15 @@ namespace RE
 			// Members
 			Entry*        templateEntry;  // 08
 			std::uint16_t idLink;         // 10
-			std::uint8_t  tingingValue;   // 12
+			std::uint8_t  tintingValue;   // 12
 		};
 		static_assert(sizeof(Entry) == 0x18);
 
 		class Entries
 		{
 		public:
-			BSTArray<Entry*> entriesA;
+			// members
+			BSTArray<Entry*> entriesA;  // 00
 		};
 		static_assert(sizeof(Entries) == 0x18);
 

include/RE/B/BSActorPathingMessage.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSPathingRequest.h"
+#include "RE/B/BSPathingSolution.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/P/PATHING_MESSAGE_TYPE.h"
+
+namespace RE
+{
+	class BSActorPathingMessage
+	{
+	public:
+		// members
+		PATHING_MESSAGE_TYPE               type;      // 00
+		BSTSmartPointer<BSPathingRequest>  request;   // 08
+		BSTSmartPointer<BSPathingSolution> solution;  // 10
+	};
+	static_assert(sizeof(BSActorPathingMessage) == 0x18);
+}

include/RE/B/BSActorPathingMessageQueue.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSActorPathingMessage.h"
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class BSActorPathingMessageQueue :
+		public BSIntrusiveRefCounted
+	{
+	public:
+		// members
+		BSTSmallArray<BSActorPathingMessage, 1> messages;      // 008
+		BSSpinLock                              messagesLock;  // 030
+	};
+	static_assert(sizeof(BSActorPathingMessageQueue) == 0x38);
+}

include/RE/B/BSPathingActorAttributes.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "RE/B/BSPathingLockData.h"
+#include "RE/B/BSTSmartPointer.h"
+
+namespace RE
+{
+	class BSPathingActorAttributes
+	{
+	public:
+		enum ACTOR_SHAPE_TYPE : std::uint32_t
+		{
+			kPoint = 0x0,
+			kBiped = 0x1,
+			kQuadruped = 0x2
+		};
+
+		enum LOCK_HANDLING_TYPE : std::uint32_t
+		{
+			kIgnore = 0x4,
+			kCantOpen = 0x8,
+			kUseLockData = 0xC
+		};
+
+		enum ATTRIBUTE : std::uint32_t
+		{
+			kWaitIfPlayerWaits = 0x80
+		};
+
+		enum TRAVERSAL_TYPE : std::uint32_t
+		{
+			kCanWalk = 0x1,
+			kCanSwim = 0x2,
+			kCanFly = 0x4,
+			kCanFloat = 0x8,
+			kIsLarge = 0x10,
+			kCanJump = 0x20
+		};
+
+		// members
+		float                              radius;          // 00
+		float                              height;          // 04
+		float                              floatHeight;     // 08
+		BSTSmartPointer<BSPathingLockData> lockData;        // 10
+		std::uint32_t                      data;            // 18
+		std::uint8_t                       traversalFlags;  // 1C
+	};
+	static_assert(sizeof(BSPathingActorAttributes) == 0x20);
+}

include/RE/B/BSPathingAvoidNodeArray.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/B/BSPathingAvoidNode.h"
+#include "RE/B/BSTArrayRefCounted.h"
+
+namespace RE
+{
+	class BSPathingAvoidNodeArray :
+		public BSTArrayRefCounted<BSPathingAvoidNode, BSTArrayHeapAllocator>  // 00
+	{
+	public:
+	};
+	static_assert(sizeof(BSPathingAvoidNodeArray) == 0x20);
+}

include/RE/B/BSPathingCell.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSTSmartPointer.h"
+
+namespace RE
+{
+	class bhkWorld;
+	class BSPathingNumericIDVisitor;
+	class BSPathingSpace;
+	class BSPathingStreamRead;
+	class BSPathingStreamWrite;
+
+	class __declspec(novtable) BSPathingCell :
+		public BSIntrusiveRefCounted  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BSPathingCell };
+		static constexpr auto VTABLE{ VTABLE::BSPathingCell };
+
+		virtual ~BSPathingCell();                                                            // 00
+		virtual std::uint32_t GetType();                                                     // 01
+		virtual void          Write(BSPathingStreamWrite* a_dst);                            // 02
+		virtual void          Read(BSPathingStreamRead* a_src);                              // 03
+		virtual void          FixupNumericID(BSPathingNumericIDVisitor* a_visitor);          // 04
+		virtual bool          IsEqual(const BSTSmartPointer<BSPathingCell>* a_other);        // 05
+		virtual void          GetSpace(BSTSmartPointer<BSPathingSpace>* a_spaceOut);         // 06
+		virtual bhkWorld*     GetBhkWorld();                                                 // 07
+		virtual bool          QValid();                                                      // 08
+		virtual bool          QAttached();                                                   // 09
+		virtual bool          QLoaded();                                                     // 0A
+		virtual bool          IsInSameSpace(const BSTSmartPointer<BSPathingCell>* a_other);  // 0B
+	};
+	static_assert(sizeof(BSPathingCell) == 0x10);
+}

include/RE/B/BSPathingLocation.h

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

include/RE/B/BSPathingLockData.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSTSmartPointer.h"
+
+namespace RE
+{
+	class BSPathingDoor;
+	class BSPathingStreamRead;
+	class BSPathingStreamWrite;
+
+	class __declspec(novtable) BSPathingLockData :
+		public BSIntrusiveRefCounted
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BSPathingLockData };
+		static constexpr auto VTABLE{ VTABLE::BSPathingLockData };
+
+		virtual ~BSPathingLockData();                                                                                  // 00
+		virtual std::uint32_t GetType();                                                                               // 01
+		virtual bool          CanTraverse(const BSTSmartPointer<BSPathingDoor>* a_door, float* a_arg2, bool* a_arg3);  // 02
+		virtual bool          CanTraverse(const BSTSmartPointer<BSPathingDoor>* a_door, float* a_arg2);                // 03
+		virtual bool          CanTraverse(const BSTSmartPointer<BSPathingDoor>* a_door);                               // 04
+		virtual void          Write(BSPathingStreamWrite* a_dst);                                                      // 05
+		virtual void          Read(BSPathingStreamRead* a_src);                                                        // 06
+	};
+	static_assert(sizeof(BSPathingLockData) == 0x10);
+}

include/RE/B/BSPathingNode.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/B/BSPathingLocation.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/M/MovementMessage.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class BSPathingNode
+	{
+	public:
+		BSPathingLocation                                                  location;      // 000
+		BSTSmartPointer<MovementMessage, BSTSmartPointerIntrusiveRefCount> actionAtNode;  // 030
+		NiPoint3                                                           tangent;       // 038
+	};
+	static_assert(sizeof(BSPathingNode) == 0x48);
+}

include/RE/B/BSPathingRequest.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSPathingActorAttributes.h"
+#include "RE/B/BSPathingGoal.h"
+#include "RE/B/BSPathingRestrictions.h"
+#include "RE/B/BSPathingSearchParameters.h"
+#include "RE/B/BSPathingStart.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/M/MeanderSettingsData.h"
+#include "RE/M/MovementActorAvoidanceParameters.h"
+
+namespace RE
+{
+	class BSPathingStreamRead;
+	class BSPathingStreamWrite;
+	class IDebugText;
+	class IMovementParameters;
+
+	class __declspec(novtable) BSPathingRequest :
+		public BSIntrusiveRefCounted  // 0008
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::BSPathingRequest };
+		static constexpr auto VTABLE{ VTABLE::BSPathingRequest };
+
+		virtual ~BSPathingRequest();                                    // 00
+		virtual std::uint32_t GetType();                                // 01
+		virtual void          CopyTo(BSPathingRequest* a_dst);          // 02
+		virtual void          Write(BSPathingStreamWrite* a_dst);       // 03
+		virtual void          Read(BSPathingStreamRead* a_src);         // 04
+		virtual void          CheckValid();                             // 05
+		virtual void          PrintDebugText(IDebugText* a_debugText);  // 06
+		virtual bool          UpdateRequest();                          // 07
+
+		// members
+		BSPathingStart                                                         start;                         // 0010
+		BSPathingGoal                                                          goal;                          // 0048
+		BSPathingRestrictions                                                  restrictions;                  // 0098
+		BSPathingSearchParameters                                              searchParameters;              // 00B0
+		BSPathingActorAttributes                                               actorAttributes;               // 00C0
+		MovementActorAvoidanceParameters                                       avoidanceParameters;           // 00E0
+		BSTSmartPointer<IMovementParameters, BSTSmartPointerIntrusiveRefCount> defaultParameters;             // 0100
+		MeanderSettingsData                                                    meanderSettings;               // 0108
+		BSTArray<BSPathingStart>                                               optionalStartArray;            // 0120
+		bool                                                                   shouldMotionCorrectStartIdle;  // 0138
+		bool                                                                   requiresPathStartIdle;         // 0139
+		bool                                                                   disablePathEndIdle;            // 013A
+	};
+	static_assert(sizeof(BSPathingRequest) == 0x140);
+}

include/RE/B/BSPathingRestrictions.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/B/BSPathingAvoidNodeArray.h"
+#include "RE/B/BSPathingSearchAreaRestrictions.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class BSPathingRestrictions
+	{
+	public:
+		NiPointer<BSPathingAvoidNodeArray> avoidNodeArray;    // 00
+		BSPathingSearchAreaRestrictions    areaRestrictions;  // 08
+	};
+	static_assert(sizeof(BSPathingRestrictions) == 0x18);
+}

include/RE/B/BSPathingSearchAreaRestrictions.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class BSPathingSearchAreaRestrictions
+	{
+	public:
+		NiPoint3 center;  // 00
+		float    radius;  // 0C
+	};
+	static_assert(sizeof(BSPathingSearchAreaRestrictions) == 0x10);
+}

include/RE/B/BSPathingSearchParameters.h

@@ -0,0 +1,29 @@
+#pragma once
+
+namespace RE
+{
+	class BSPathingSearchParameters
+	{
+	public:
+		enum Flags : std::uint16_t
+		{
+			kAllowIncompletePath = 0x1,
+			kGoDirectIfPathingFails = 0x2,
+			kIgnoreSmoothingIfFails = 0x4,
+			kUsePrefferedPath = 0x8,
+			kRequiresHavok = 0x10,
+			kAvoidPreferredPath = 0x20,
+			kMustQueue = 0x40,
+			kCanShortcut = 0x80,
+			kAllowUnattachedCell = 0x100,
+			kProcessSynchronously = 0x200,
+			kResolveGoalToClosest = 0x400
+		};
+
+		float                               preferredCostFactor;     // 00
+		float                               tangentSmoothingFactor;  // 04
+		std::uint16_t                       retryCount;              // 08
+		REX::TEnumSet<Flags, std::uint16_t> flags;                   // 0A
+	};
+	static_assert(sizeof(BSPathingSearchParameters) == 0x0C);
+}

include/RE/B/BSPathingSolution.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/B/BSPathingNode.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSVirtualPathingNode.h"
+
+namespace RE
+{
+	class BSPathingSolution :
+		public BSIntrusiveRefCounted  // 00
+	{
+	public:
+		// members
+		BSTSmallArray<BSVirtualPathingNode, 2> virtualPathingNodes;          // 008
+		std::int32_t                           firstLoadedVirtualNodeIndex;  // 088
+		std::int32_t                           lastLoadedVirtualNodeIndex;   // 08C
+		BSTArray<BSPathingNode>                currentPathingNodes;          // 090
+		float                                  goalRadius;                   // 0A8
+		bool                                   incompletePath;               // 0AC
+		bool                                   requestGoalUnused;            // 0AD
+	};
+	static_assert(sizeof(BSPathingSolution) == 0xB0);
+}

include/RE/B/BSTArrayRefCounted.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	template <class T, class Allocator = BSTArrayHeapAllocator>
+	class alignas(0x8) BSTArrayRefCounted :
+		public BSTArray<T, Allocator>,  // 00
+		public BSIntrusiveRefCounted    // 18
+	{
+	public:
+	};
+}

include/RE/B/BSVirtualPathingNode.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/B/BSPathingLocation.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/M/MovementMessage.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class BSVirtualPathingNode
+	{
+	public:
+		// members
+		BSPathingLocation                                                  location;      // 000
+		BSTSmartPointer<MovementMessage, BSTSmartPointerIntrusiveRefCount> actionAtNode;  // 030
+	};
+	static_assert(sizeof(BSVirtualPathingNode) == 0x38);
+}

include/RE/E/EXTRA_DATA_TYPE.h

@@ -93,7 +93,7 @@ namespace RE
 		kImageSpace,                    //
 		kNavmeshPortal,                 //
 		kModelSwap,                     //
-		kRadius,                        //
+		kRadius,                        // ExtraRadius
 		kRadiation,                     //
 		kFactionChanges,                // ExtraFactionChanges
 		kDismemberedLimbs,              //