docs: add plugin setup guide

plugin/lib/commonlibf4/include/RE/P/PACKAGE_DATA.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace RE
+{
+	class PACKAGE_DATA
+	{
+	public:
+		// members
+		std::uint32_t packFlags;              // 0
+		std::int8_t   packType;               // 4
+		std::int8_t   interruptOverrideType;  // 5
+		std::int8_t   maxSpeed;               // 6
+		std::uint16_t foBehaviorFlags;        // 8
+		std::uint16_t packageSpecificFlags;   // A
+	};
+	static_assert(sizeof(PACKAGE_DATA) == 0xC);
+}

plugin/lib/commonlibf4/include/RE/P/PACKAGE_OBJECT_TYPE.h

@@ -0,0 +1,38 @@
+#pragma once
+
+namespace RE
+{
+	enum class PACKAGE_OBJECT_TYPE : std::int32_t
+	{
+		kNone = 0x0,
+		kActi = 0x1,
+		kArmo = 0x2,
+		kBook = 0x3,
+		kCont = 0x4,
+		kDoor = 0x5,
+		kIngr = 0x6,
+		kLigh = 0x7,
+		kMisc = 0x8,
+		kFlor = 0x9,
+		kFurn = 0xA,
+		kWeap = 0xB,
+		kAmmo = 0xC,
+		kKeym = 0xD,
+		kAlch = 0xE,
+		kFood = 0xF,
+		kClot = 0x10,
+		kWear = 0x11,
+		kWeapNone = 0x12,
+		kWeapMelee = 0x13,
+		kWeapRanged = 0x14,
+		kSpell = 0x15,
+		kSpellRanged = 0x16,
+		kSpellTouch = 0x17,
+		kSpellSelf = 0x18,
+		kActor = 0x19,
+		kFurnBed = 0x1A,
+		kFurnChair = 0x1B,
+		kShout = 0x1C,
+		kHeadtrack = 0x1D,
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PACK_EVENT_ACTION_TYPE.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class PACK_EVENT_ACTION_TYPE
+	{
+		kBegin = 0x0,
+		kEnd = 0x1,
+		kChange = 0x2,
+		kPatrol = 0x3,
+		kTotal = 0x4
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PACK_SCHED_DATA.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace RE
+{
+	class PACK_SCHED_DATA
+	{
+	public:
+		// members
+		std::int8_t  month;      // 0
+		std::int8_t  dayOfWeek;  // 1
+		std::int8_t  date;       // 2
+		std::int8_t  hour;       // 3
+		std::int8_t  min;        // 4
+		std::int32_t duration;   // 8
+	};
+	static_assert(sizeof(PACK_SCHED_DATA) == 0xC);
+}

plugin/lib/commonlibf4/include/RE/P/PART_DATA.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class PART_DATA
+	{
+	public:
+		// members
+		float             damageMult;                    // 00
+		BGSDebris*        explosionGenericDebris;        // 08
+		BGSExplosion*     explosion;                     // 10
+		float             explosionGenericDebrisScale;   // 18
+		BGSDebris*        dismemberGenericDebris;        // 20
+		BGSExplosion*     dismemberExplosion;            // 28
+		float             dismemberGenericDebrisScale;   // 30
+		BGSDebris*        onCrippleGenericDebris;        // 38
+		BGSExplosion*     onCrippleExplosion;            // 40
+		float             onCrippleGenericDebrisScale;   // 48
+		NiPoint3          goreTranslate;                 // 4C
+		NiPoint3          goreRotate;                    // 58
+		BGSImpactDataSet* dismemberImpactDataSet;        // 68
+		BGSImpactDataSet* explosionImpactDataSet;        // 70
+		BGSImpactDataSet* onCrippleImpactDataSet;        // 78
+		ActorValueInfo*   actorValue;                    // 80
+		BGSArtObject*     artObject;                     // 88
+		float             explosionSpecialDebrisScale;   // 90
+		std::uint8_t      flags;                         // 94
+		std::uint8_t      type;                          // 95
+		std::uint8_t      healthPercent;                 // 96
+		std::uint8_t      toHitChance;                   // 97
+		std::uint8_t      explosionChance;               // 98
+		std::uint8_t      nonLethalDismembermentChance;  // 99
+		std::uint8_t      dismemberGenericDebrisCount;   // 9A
+		std::uint8_t      onCrippleGenericDebrisCount;   // 9B
+		std::uint8_t      explosionGenericDebrisCount;   // 9C
+		std::uint8_t      dismemberDecalCount;           // 9D
+		std::uint8_t      onCrippleDecalCount;           // 9E
+		std::uint8_t      explosionDecalCount;           // 9F
+		std::uint8_t      geometrySegmentIndex;          // A0
+	};
+	static_assert(sizeof(PART_DATA) == 0xA8);
+}

plugin/lib/commonlibf4/include/RE/P/PATH_DATA.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	class PATH_DATA
+	{
+	public:
+		// members
+		std::int8_t flags;  // 0
+	};
+	static_assert(sizeof(PATH_DATA) == 0x1);
+}

plugin/lib/commonlibf4/include/RE/P/PC_GAMEPAD_TYPE.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class PC_GAMEPAD_TYPE : std::int32_t
+	{
+		kDirectX = 0x0,
+		kOrbis = 0x1,
+
+		kTotal
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PERK_ENTRY_TYPE.h

@@ -0,0 +1,10 @@
+namespace RE
+{
+	enum class PERK_ENTRY_TYPE
+	{
+		kQuest = 0x0,
+		kAbility = 0x1,
+		kEntryPoint = 0x2,
+		kTotal = 0x3
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PIPBOY_PAGES.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class PIPBOY_PAGES : std::int32_t
+	{
+		kStat = 0x0,
+		kInv = 0x1,
+		kData = 0x2,
+		kMap = 0x3,
+		kRadio = 0x4
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PLAYER_ACTION.h

@@ -0,0 +1,24 @@
+#pragma once
+
+namespace RE
+{
+	enum class PLAYER_ACTION : std::int32_t
+	{
+		kNone = 0x0,
+		kSwingMeleeWeapon = 0x1,
+		kCastProjectileSpell = 0x2,
+		kShootBow = 0x3,
+		kZKeyObject = 0x4,
+		kJumping = 0x5,
+		kKnockingOverObjects = 0x6,
+		kStandOnTableChair = 0x7,
+		kIronSights = 0x8,
+		kDestroyObject = 0x9,
+		kLockedObject = 0xA,
+		kPickpocket = 0xB,
+		kCastSelfSpell = 0xC,
+		kShout = 0xD,
+		kActorCollision = 0xE,
+		kInvalidMarker = 0x10,
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PLAYER_TARGET_LOC.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class DoorTeleportData;
+
+	class PLAYER_TARGET_LOC
+	{
+	public:
+		using ArrivalFunc_t = void(void*);
+
+		// members
+		TESWorldSpace*    world;             // 00
+		TESObjectCELL*    interior;          // 08
+		DoorTeleportData* transitionTel;     // 10
+		NiPoint3          location;          // 18
+		NiPoint3          angle;             // 24
+		TESObjectREFR*    walkThroughDoor;   // 30
+		ArrivalFunc_t*    arrivalFunc;       // 38
+		void*             arrivalFuncData;   // 40
+		ObjectRefHandle   furnitureRef;      // 48
+		ObjectRefHandle   fastTravelMarker;  // 4C
+		float             fastTravelDist;    // 50
+		bool              resetWeather;      // 54
+		bool              allowAutoSave;     // 55
+		bool              preventLoadMenu;   // 56
+		bool              skyTransition;     // 57
+		bool              isValid;           // 58
+	};
+	static_assert(sizeof(PLAYER_TARGET_LOC) == 0x60);
+}

plugin/lib/commonlibf4/include/RE/P/POWER_ARMOR_HUD_VISIBILITY_RULE.h

@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class POWER_ARMOR_HUD_VISIBILITY_RULE : std::int32_t
+	{
+		kIgnoresPAHUDVisibility = 0x0,
+		kOnlyWithPAHUDVisible = 0x1,
+		kOnlyWithPAHUDNotVisible = 0x2
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PTYPE.h

@@ -0,0 +1,54 @@
+#pragma once
+
+namespace RE
+{
+	enum class PTYPE : std::int32_t
+	{
+		kExplore = 0x0,
+		kFollow = 0x1,
+		kEscore = 0x2,
+		kEat = 0x3,
+		kSleep = 0x4,
+		kWander = 0x5,
+		kTravel = 0x6,
+		kAccompany = 0x7,
+		kUseItemAt = 0x8,
+		kAmbush = 0x9,
+		kFleeNonCombat = 0xA,
+		kCastMagic = 0xB,
+		kSandbox = 0xC,
+		kPatrol = 0xD,
+		kGuard = 0xE,
+		kDialogue = 0xF,
+		kUseWeapon = 0x10,
+		kFind = 0x11,
+		kCustom = 0x12,
+		kTemplate = 0x13,
+		kActivate = 0x14,
+		kAlarm = 0x15,
+		kFlee = 0x16,
+		kTrespass = 0x17,
+		kSpectator = 0x18,
+		kGreet = 0x19,
+		kGetUp = 0x1A,
+		kDoNothing = 0x1B,
+		kInGameDialogue = 0x1C,
+		kSurface = 0x1D,
+		kSearchForAttacker = 0x1E,
+		kAvoidReference = 0x1F,
+		kBumpReaction = 0x20,
+		kGrenadeMineReaction = 0x21,
+		kStealWarning = 0x22,
+		kPickpocketWarning = 0x23,
+		kMovementBlocked = 0x24,
+		kVampireFeed = 0x25,
+		kCannibal = 0x26,
+		kLand = 0x27,
+		kUnused = 0x28,
+		kMountActor = 0x29,
+		kDismountActor = 0x2A,
+		kClearMountPosition = 0x2B,
+		kClearPowerArmorExit = 0x2C,
+		kCount = 0x2D
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PackageEventAction.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "RE/B/BGSTopicSubtypeUnion.h"
+#include "RE/P/PACK_EVENT_ACTION_TYPE.h"
+
+namespace RE
+{
+	class PackageEventAction
+	{
+	public:
+		// members
+		TESIdleForm*                                        idle;               // 00
+		REX::TEnumSet<PACK_EVENT_ACTION_TYPE, std::int32_t> type;               // 08
+		BGSTopicSubtypeUnion                                topicSubtypeUnion;  // 0C
+	};
+	static_assert(sizeof(PackageEventAction) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PackageList.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/B/BSSimpleList.h"
+
+namespace RE
+{
+	class PackageList
+	{
+	public:
+		// members
+		BSSimpleList<TESPackage*> listPackages;
+	};
+	static_assert(sizeof(PackageList) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/P/PackageNS.h

@@ -0,0 +1,18 @@
+#pragma once
+
+namespace RE
+{
+	namespace PackageNS
+	{
+		enum class CRIME_TYPE
+		{
+			kSteal = 0x0,
+			kPickpocket = 0x1,
+			kTrespass = 0x2,
+			kAttack = 0x3,
+			kMurder = 0x4,
+			kEscape = 0x5,
+			kUnused = 0x6
+		};
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PackageSchedule.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/P/PACK_SCHED_DATA.h"
+
+namespace RE
+{
+	class PackageSchedule
+	{
+	public:
+		// members
+		PACK_SCHED_DATA psData;  // 0
+	};
+	static_assert(sizeof(PackageSchedule) == 0xC);
+}

plugin/lib/commonlibf4/include/RE/P/ParentSpaceNode.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	struct ParentSpaceNode
+	{
+	public:
+		// members
+		bool           worldspace;    // 00
+		TESWorldSpace* worldSpace;    // 08
+		TESObjectCELL* interiorCell;  // 10
+	};
+	static_assert(sizeof(ParentSpaceNode) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PauseMenu.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "RE/R/Rumble.h"
+#include "RE/S/StartMenuBase.h"
+
+namespace RE
+{
+	class __declspec(novtable) PauseMenu :
+		public StartMenuBase  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PauseMenu };
+		static constexpr auto VTABLE{ VTABLE::PauseMenu };
+		static constexpr auto MENU_NAME{ "PauseMenu"sv };
+
+		// members
+		std::unique_ptr<BSGFxShaderFXTarget> helpTopicList;            // 228
+		std::unique_ptr<BSGFxShaderFXTarget> helpPanelBrackets;        // 230
+		std::unique_ptr<BSGFxShaderFXTarget> helpListBrackets;         // 238
+		std::unique_ptr<BSGFxShaderFXTarget> helpText;                 // 240
+		std::unique_ptr<BSGFxShaderFXTarget> helpTitleText;            // 248
+		std::unique_ptr<BSGFxShaderFXTarget> helpScrollUp;             // 250
+		std::unique_ptr<BSGFxShaderFXTarget> helpScrollDown;           // 258
+		Rumble::AutoRumblePause              rumbleLock;               // 260
+		bool                                 hideScreen3D;             // 261
+		bool                                 modMenuShaderWasEnabled;  // 262
+		bool                                 vatsWasEnabled;           // 263
+		bool                                 vatsDepthTestMask;        // 264
+		bool                                 quitToMainMenuQueued;     // 265
+		bool                                 quitToDesktopQueued;      // 266
+		bool                                 noProfileSelected;        // 267
+	};
+	static_assert(sizeof(PauseMenu) == 0x268);
+}

plugin/lib/commonlibf4/include/RE/P/PerkAdded.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	namespace PerkAdded
+	{
+		class Event
+		{
+		public:
+			const Actor*   adder;
+			const BGSPerk* perk;
+			std::uint8_t   rank;
+		};
+		static_assert(sizeof(Event) == 0x18);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PerkData.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	class PerkData
+	{
+	public:
+		// members
+		bool        trait;     // 0
+		std::int8_t level;     // 1
+		std::int8_t numRanks;  // 2
+		bool        playable;  // 3
+		bool        hidden;    // 4
+	};
+	static_assert(sizeof(PerkData) == 0x5);
+}

plugin/lib/commonlibf4/include/RE/P/PerkPointIncreaseEvent.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class PerkPointIncreaseEvent
+	{
+	private:
+		using EventSource_t = BSTGlobalEvent::EventSource<PerkPointIncreaseEvent>;
+
+	public:
+		PerkPointIncreaseEvent(std::uint8_t a_perkCount) :
+			perkCount(a_perkCount)
+		{}
+
+		[[nodiscard]] static EventSource_t* GetEventSource()
+		{
+			static REL::Relocation<EventSource_t**> singleton{ ID::PerkPointIncreaseEvent::GetEventSource };
+			if (!*singleton) {
+				*singleton = new EventSource_t(&BSTGlobalEvent::GetSingleton()->eventSourceSDMKiller);
+			}
+			return *singleton;
+		}
+
+		// members
+		std::uint8_t perkCount{ 0 };  // 00
+	};
+	static_assert(sizeof(PerkPointIncreaseEvent) == 0x1);
+}

plugin/lib/commonlibf4/include/RE/P/PerkRankData.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/M/MemoryManager.h"
+
+namespace RE
+{
+	class PerkRankData
+	{
+	public:
+		PerkRankData(BGSPerk* a_perk, std::int8_t a_rank) :
+			perk(a_perk), currentRank(a_rank)
+		{}
+
+		F4_HEAP_REDEFINE_NEW(PerkRankData);
+
+		// members
+		BGSPerk*    perk;         // 00
+		std::int8_t currentRank;  // 08
+	};
+	static_assert(sizeof(PerkRankData) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/P/PerkUtilities.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	namespace PerkUtilities
+	{
+		inline void RemoveGrenadeTrajectory()
+		{
+			using func_t = decltype(&RemoveGrenadeTrajectory);
+			static REL::Relocation<func_t> func{ ID::PerkUtilities::RemoveGrenadeTrajectory };
+			return func();
+		}
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PerkValueEvents.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+
+namespace RE
+{
+	class BGSPerkEntry;
+
+	namespace PerkValueEvents
+	{
+		enum class Type : std::int32_t
+		{
+			kAdd = 0x0,
+			kRemove = 0x1
+		};
+
+		class PerkValueChangedEvent
+		{
+		public:
+			// members
+			Type         changeType;  // 00
+			ActorHandle  owner;       // 04
+			BGSPerk*     perk;        // 08
+			std::uint8_t rank;        // 10
+		};
+		static_assert(sizeof(PerkValueChangedEvent) == 0x18);
+
+		class PerkEntryUpdatedEvent
+		{
+		public:
+			// members
+			ActorHandle   owner;      // 00
+			BGSPerkEntry* perkEntry;  // 08
+		};
+		static_assert(sizeof(PerkEntryUpdatedEvent) == 0x10);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PersistentPassList.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	class BSRenderPass;
+
+	class PersistentPassList
+	{
+	public:
+		// members
+		BSRenderPass* head;  // 00
+		BSRenderPass* tail;  // 08
+	};
+	static_assert(sizeof(PersistentPassList) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyArray.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/P/PipboyValue.h"
+
+namespace RE
+{
+	class PipboyArray :
+		public PipboyValue  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyArray };
+		static constexpr auto VTABLE{ VTABLE::PipboyArray };
+
+		// members
+		BSTArray<PipboyValue*>  elements;           // 18
+		BSTSet<std::uint32_t>   addedElementIDs;    // 30
+		BSTArray<std::uint32_t> removedElementIDs;  // 60
+		bool                    newlyCreated;       // 78
+	};
+	static_assert(sizeof(PipboyArray) == 0x80);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyCommand.h

@@ -0,0 +1,32 @@
+#pragma once
+
+namespace RE
+{
+	class PipboyCommandResult;
+
+	class __declspec(novtable) PipboyCommand
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyCommand };
+		static constexpr auto VTABLE{ VTABLE::PipboyCommand };
+
+		PipboyCommand(std::uint32_t a_id) :
+			id(a_id)
+		{
+			REX::EMPLACE_VTABLE(this);
+		}
+
+		// add
+		virtual ~PipboyCommand();                                          // 00
+		virtual void                       Init(Json::Value* a_json) = 0;  // 01
+		virtual const PipboyCommandResult* DoValidate();                   // 02
+		virtual const PipboyCommandResult* DoExecute();                    // 03
+
+		// members
+		const std::uint32_t        id;                           // 0x08
+		const PipboyCommandResult* validationResult{ nullptr };  // 0x10
+		const PipboyCommandResult* executionResult{ nullptr };   // 0x18
+		bool                       isReadonOnly{ false };        // 0x20
+	};
+	static_assert(sizeof(PipboyCommand) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyCommandResult.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace RE
+{
+	class __declspec(novtable) PipboyCommandResult
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyCommandResult };
+		static constexpr auto VTABLE{ VTABLE::PipboyCommandResult };
+
+		PipboyCommandResult(std::uint32_t a_commandId, bool a_succeeded, bool a_shouldReply) :
+			commandId(a_commandId), succeeded(a_succeeded), shouldReply(a_shouldReply)
+		{
+			REX::EMPLACE_VTABLE(this);
+		}
+
+		// add
+		virtual ~PipboyCommandResult();                   // 00
+		virtual void Serialize(Json::Value* a_json) = 0;  // 01
+
+		// members
+		const std::uint32_t commandId;    // 08
+		const bool          succeeded;    // 0C
+		const bool          shouldReply;  // 0D
+	};
+	static_assert(sizeof(PipboyCommandResult) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyDataGroup.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class PipboyArray;
+	class PipboyObject;
+	class PipboyThrottleManager;
+	class PipboyValue;
+	class PipboyValueChangedEvent;
+
+	class PipboyDataGroup :
+		public BSTEventSource<PipboyValueChangedEvent>  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyDataGroup };
+		static constexpr auto VTABLE{ VTABLE::PipboyDataGroup };
+
+		virtual ~PipboyDataGroup() = default;  // 00
+
+		// override
+		virtual BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource<PipboyValueChangedEvent>* a_source);  // 01
+
+		// add
+		virtual void Populate(bool a_arg1) = 0;  // 02
+		virtual void DoClearData() = 0;          // 03
+		virtual void DoClearSink() = 0;          // 04
+
+		void LockDataGroup()
+		{
+			using func_t = decltype(&PipboyDataGroup::LockDataGroup);
+			static REL::Relocation<func_t> func{ ID::PipboyDataGroup::LockDataGroup };
+			return func(this);
+		}
+
+		void UnlockDataGroup()
+		{
+			using func_t = decltype(&PipboyDataGroup::UnlockDataGroup);
+			static REL::Relocation<func_t> func{ ID::PipboyDataGroup::UnlockDataGroup };
+			return func(this);
+		}
+
+		// members
+		REX::W32::CRITICAL_SECTION pipboyDataMutex;  // 60
+		PipboyThrottleManager*     throttleManager;  // 88
+		PipboyValue*               rootValue;        // 90
+	};
+	static_assert(sizeof(PipboyDataGroup) == 0x98);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyDataManager.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "RE/B/BSTSingleton.h"
+#include "RE/P/PipboyInventoryData.h"
+#include "RE/P/PipboyLogData.h"
+#include "RE/P/PipboyMapData.h"
+#include "RE/P/PipboyObject.h"
+#include "RE/P/PipboyPerksData.h"
+#include "RE/P/PipboyPlayerInfoData.h"
+#include "RE/P/PipboyQuestData.h"
+#include "RE/P/PipboyRadioData.h"
+#include "RE/P/PipboySpecialData.h"
+#include "RE/P/PipboyStatsData.h"
+#include "RE/P/PipboyStatusData.h"
+#include "RE/P/PipboyThrottleManager.h"
+#include "RE/P/PipboyWorkshopData.h"
+
+namespace RE
+{
+	class _declspec(novtable) PipboyDataManager :
+		public BSTSingletonSDM<PipboyDataManager>  // 00
+	{
+	public:
+		[[nodiscard]] static PipboyDataManager* GetSingleton()
+		{
+			static REL::Relocation<PipboyDataManager**> singleton{ ID::PipboyDataManager::Singleton };
+			return *singleton;
+		}
+
+		// members
+		PipboyObject          rootObject;       // 008
+		PipboyStatsData       statsData;        // 0A0
+		PipboySpecialData     specialData;      // 1D8
+		PipboyPerksData       perksData;        // 280
+		PipboyInventoryData   inventoryData;    // 358
+		PipboyQuestData       questData;        // 4F0
+		PipboyWorkshopData    workshopData;     // 5D8
+		PipboyLogData         logData;          // 718
+		PipboyMapData         mapData;          // 7F0
+		PipboyRadioData       radioData;        // A28
+		PipboyPlayerInfoData  playerInfoData;   // AD8
+		PipboyStatusData      statusData;       // BE0
+		PipboyDataGroup*      dataGroups[11];   // CC0
+		PipboyThrottleManager throttleManager;  // D18
+	};
+	static_assert(sizeof(PipboyDataManager) == 0xD48);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyHolotapeMenu.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/H/HolotapeMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyHolotapeMenu :
+		public HolotapeMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyHolotapeMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyHolotapeMenu };
+		static constexpr auto MENU_NAME{ "PipboyHolotapeMenu"sv };
+
+		virtual ~PipboyHolotapeMenu();  // 00
+
+		// override (HolotapeMenu)
+		virtual void ProcessCancel() override;  // 14
+
+		// members
+		bool wasPipboyActive;  // 108
+	};
+	static_assert(sizeof(PipboyHolotapeMenu) == 0x110);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyInventoryData.h

@@ -0,0 +1,240 @@
+#pragma once
+
+#include "RE/B/BGSInventoryItem.h"
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/E/ENUM_FORM_ID.h"
+#include "RE/I/InventoryInterface.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace ActorEquipManagerEvent
+	{
+		class Event;
+	}
+
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent;
+	}
+
+	namespace BGSInventoryItemEvent
+	{
+		class Event;
+	}
+
+	namespace BGSInventoryListEvent
+	{
+		class Event;
+	}
+
+	namespace HolotapeStateChanged
+	{
+		class Event;
+	}
+
+	namespace InventoryInterface
+	{
+		class FavoriteChangedEvent;
+	}
+
+	namespace FavoriteMgr_Events
+	{
+		class ComponentFavoriteEvent;
+	}
+
+	namespace PerkValueEvents
+	{
+		class PerkValueChangedEvent;
+		class PerkEntryUpdatedEvent;
+	}
+
+	namespace PlayerDifficultySettingChanged
+	{
+		class Event;
+	}
+
+	class PipboyInventoryData :
+		public PipboyDataGroup,                                           // 00
+		public BSTEventSink<BGSInventoryListEvent::Event>,                // 98
+		public BSTEventSink<ActorEquipManagerEvent::Event>,               // A0
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,    // A8
+		public BSTEventSink<PerkValueEvents::PerkEntryUpdatedEvent>,      // B0
+		public BSTEventSink<PerkValueEvents::PerkValueChangedEvent>,      // B8
+		public BSTEventSink<InventoryInterface::FavoriteChangedEvent>,    // C0
+		public BSTEventSink<HolotapeStateChanged::Event>,                 // C8
+		public BSTEventSink<BGSInventoryItemEvent::Event>,                // D0
+		public BSTEventSink<FavoriteMgr_Events::ComponentFavoriteEvent>,  // D8
+		public BSTEventSink<PlayerDifficultySettingChanged::Event>        // E0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyInventoryData };
+		static constexpr auto VTABLE{ VTABLE::PipboyInventoryData };
+
+		virtual ~PipboyInventoryData();
+
+		enum class ENTRY_TYPE
+		{
+			kInt = 0x0,
+			kFixedString = 0x1,
+			kFloat = 0x1
+		};
+
+		enum class ITEM_ICON_ID
+		{
+			kNone = 0x1,
+			kBasicPistol = 0x2,
+			kLaserPistol = 0x3,
+			kPlasmaPistol = 0x4,
+			kShotgun = 0x5,
+			kBasicRifle = 0x6,
+			kAssaultRifle = 0x7,
+			kGaussRifle = 0x8,
+			kLaserMusket = 0x9,
+			kLaserRifle = 0xA,
+			kPlasmaRifle = 0xB,
+			k1hMelee = 0xC,
+			k2hMelee = 0xD,
+			kH2hWeap = 0xE,
+			kMissileLauncher = 0xF,
+			kFatman = 0x10,
+			kMinigun = 0x11,
+			kGatlingLaser = 0x12,
+			kCryolator = 0x13,
+			kFlamer = 0x14,
+			kFlareGun = 0x15,
+			kGammaGun = 0x16,
+			kJunkJet = 0x17,
+			kRailwayRifle = 0x18,
+			kSyringer = 0x19,
+			kBroadsider = 0x1A,
+			kAlienBlaster = 0x1B,
+			kRipper = 0x1C,
+			kShishkebab = 0x1D,
+			kThrownWeap = 0x1E,
+			kExplosiveMine = 0x1F,
+			kBottlecapMine = 0x20,
+			kCryoMine = 0x21,
+			kCryoGrenade = 0x22,
+			kPlasmaMine = 0x23,
+			kPlasmaGrenade = 0x24,
+			kPulseMine = 0x25,
+			kPulseGrenade = 0x26,
+			kMolotov = 0x27,
+			kNukaGrenade = 0x28,
+			kRepairKit = 0x29,
+			kSurgeryKit = 0x2A,
+			kArmor = 0x2B,
+			kGloves = 0x2C,
+			kHelmet = 0x2D,
+			kBook = 0x2E,
+			kClothes = 0x2F,
+			kAmmo = 0x30,
+			kAdrenaline = 0x31,
+			kDisease = 0x32,
+			kSleep = 0x33,
+			kHunger = 0x34,
+			kThirst = 0x35,
+			kChems = 0x36,
+			kStimpak = 0x37,
+			kFood = 0x38,
+			kAlcohol = 0x39,
+			kStealthBoy = 0x3A,
+			kUnknown = 0x3B,
+			kMax = 0x3B
+		};
+
+		enum class SORT_ON_FIELD
+		{
+			kAlphabetically = 0x0,
+			kDamage = 0x1,
+			kRof = 0x2,
+			kRange = 0x3,
+			kAccuracy = 0x4,
+			kValue = 0x5,
+			kWeight = 0x6
+		};
+
+		class StackEntry
+		{
+		public:
+			// members
+			PipboyObject*                    linkedObject;     // 00
+			const InventoryInterface::Handle inventoryHandle;  // 08
+		};
+		static_assert(sizeof(StackEntry) == 0x10);
+
+		class ItemEntry
+		{
+		public:
+			// members
+			void* stackEntries;  // 00 - BSTList<PipboyInventoryData::StackEntry*>
+		};
+		static_assert(sizeof(ItemEntry) == 0x8);
+
+		// override
+		virtual BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource<PipboyValueChangedEvent>* a_source);  // 01
+
+		// add
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);                              // 02
+		virtual BSEventNotifyControl ProcessEvent(const ActorEquipManagerEvent::Event& a_event, BSTEventSource<ActorEquipManagerEvent::Event>* a_source);                            // 03
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);      // 04
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkEntryUpdatedEvent& a_event, BSTEventSource<PerkValueEvents::PerkEntryUpdatedEvent>* a_source);          // 05
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkValueChangedEvent& a_event, BSTEventSource<PerkValueEvents::PerkValueChangedEvent>* a_source);          // 06
+		virtual BSEventNotifyControl ProcessEvent(const InventoryInterface::FavoriteChangedEvent& a_event, BSTEventSource<InventoryInterface::FavoriteChangedEvent>* a_source);      // 07
+		virtual BSEventNotifyControl ProcessEvent(const HolotapeStateChanged::Event& a_event, BSTEventSource<HolotapeStateChanged::Event>* a_source);                                // 08
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource<BGSInventoryItemEvent::Event>* a_source);                              // 09
+		virtual BSEventNotifyControl ProcessEvent(const FavoriteMgr_Events::ComponentFavoriteEvent& a_event, BSTEventSource<FavoriteMgr_Events::ComponentFavoriteEvent>* a_source);  // 0A
+		virtual BSEventNotifyControl ProcessEvent(const PlayerDifficultySettingChanged::Event& a_event, BSTEventSource<PlayerDifficultySettingChanged::Event>* a_source);            // 0B
+
+		virtual void Populate(bool a_arg1);  // 0C
+		virtual void DoClearData();          // 0D
+		virtual void DoClearSink();          // 0E
+
+		void AddItemCardInfoEntry(const BSFixedStringCS* a_string, float a_value, PipboyArray* a_itemCardSection)
+		{
+			using func_t = decltype(&PipboyInventoryData::AddItemCardInfoEntry);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::AddItemCardInfoEntry };
+			return func(this, a_string, a_value, a_itemCardSection);
+		}
+
+		PipboyObject* BaseAddItemCardInfoEntry(const BSFixedStringCS* a_string, PipboyArray* a_itemCardSection)
+		{
+			using func_t = decltype(&PipboyInventoryData::BaseAddItemCardInfoEntry);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::BaseAddItemCardInfoEntry };
+			return func(this, a_string, a_itemCardSection);
+		}
+
+		void PopulateItemCardInfo(const BGSInventoryItem* a_inventoryItem, const BGSInventoryItem::Stack* a_stack, PipboyObject* a_data)
+		{
+			using func_t = decltype(&PipboyInventoryData::PopulateItemCardInfo);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::PopulateItemCardInfo };
+			return func(this, a_inventoryItem, a_stack, a_data);
+		}
+
+		void QueueItemCardRepopulate(ENUM_FORM_ID a_formType)
+		{
+			using func_t = decltype(&PipboyInventoryData::QueueItemCardRepopulate);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::QueueItemCardRepopulate };
+			return func(this, a_formType);
+		}
+
+		void RepopulateItemCardOnSection(ENUM_FORM_ID a_itemTypeID)
+		{
+			using func_t = decltype(&PipboyInventoryData::RepopulateItemCardOnSection);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryData::RepopulateItemCardOnSection };
+			return func(this, a_itemTypeID);
+		}
+
+		// members
+		PipboyObject*                                             inventoryObject;             // E8
+		BSTHashMap<std::uint32_t, PipboyInventoryData::ItemEntry> itemEntries;                 // F0
+		BSTHashMap<const BGSComponent*, PipboyObject*>            invComponents;               // 120
+		BSTArray<PipboyObject*>                                   sortedItems;                 // 150
+		BSTSet<ENUM_FORM_ID>                                      queuedRepopulateCategories;  // 168
+	};
+	static_assert(sizeof(PipboyInventoryData) == 0x198);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyInventoryMenu.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyInventoryMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyInventoryMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyInventoryMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyInventoryMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryMenu::UpdateData };
+			return func(this);
+		}
+
+		void SetQuickkey(int a_selectedIndex, int a_quickkeyIndex)
+		{
+			using func_t = decltype(&PipboyInventoryMenu::SetQuickkey);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryMenu::SetQuickkey };
+			return func(this, a_selectedIndex, a_quickkeyIndex);
+		}
+	};
+	static_assert(sizeof(PipboyInventoryMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyInventoryUtils.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "RE/B/BGSInventoryItem.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTTuple.h"
+
+namespace RE
+{
+	namespace PipboyInventoryUtils
+	{
+		enum class PAPER_DOLL_ARMOR_SLOTS
+		{
+			kUnderwear = 0x0,
+			kLeftLeg = 0x1,
+			kRightLeg = 0x2,
+			kLeftArm = 0x3,
+			kRightArm = 0x4,
+			kTorso = 0x5,
+			kHelmet = 0x6,
+			kGoggles = 0x7,
+			kGasMask = 0x8
+		};
+
+		inline bool DoSlotsOverlap(const TESObjectARMO* a_armor1, const TESObjectARMO* a_armor2)
+		{
+			using func_t = decltype(&DoSlotsOverlap);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryUtils::DoSlotsOverlap };
+			return func(a_armor1, a_armor2);
+		}
+
+		inline void FillDamageTypeInfo(const BGSInventoryItem& a_item, const BGSInventoryItem::Stack* a_stack, BSScrapArray<BSTTuple<std::uint32_t, float>>& a_damageValuesPerType)
+		{
+			using func_t = decltype(&FillDamageTypeInfo);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryUtils::FillDamageTypeInfo };
+			return func(a_item, a_stack, a_damageValuesPerType);
+		}
+
+		inline void FillResistTypeInfo(const BGSInventoryItem& a_item, const BGSInventoryItem::Stack* a_stack, BSScrapArray<BSTTuple<std::uint32_t, float>>& a_resistValuesPerType, float a_scale)
+		{
+			using func_t = decltype(&FillResistTypeInfo);
+			static REL::Relocation<func_t> func{ ID::PipboyInventoryUtils::FillResistTypeInfo };
+			return func(a_item, a_stack, a_resistValuesPerType, a_scale);
+		}
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PipboyLightEvent.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class PipboyLightEvent :
+		public BSTValueEvent<bool>
+	{
+	private:
+		using EventSource_t = BSTGlobalEvent::EventSource<PipboyLightEvent>;
+
+	public:
+		[[nodiscard]] static EventSource_t* GetEventSource()
+		{
+			static REL::Relocation<EventSource_t**> singleton{ ID::PipboyLightEvent::GetEventSource };
+			if (!*singleton) {
+				*singleton = new EventSource_t(&BSTGlobalEvent::GetSingleton()->eventSourceSDMKiller);
+			}
+			return *singleton;
+		}
+	};
+	static_assert(sizeof(PipboyLightEvent) == 0x2);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyLogData.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	class TESTrackedStatsEvent;
+
+	class __declspec(novtable) PipboyLogData :
+		public PipboyDataGroup,                    // 00
+		public BSTEventSink<TESTrackedStatsEvent>  // 98
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyLogData };
+		static constexpr auto VTABLE{ VTABLE::PipboyLogData };
+
+		virtual ~PipboyLogData() = default;  // 00
+
+		virtual BSEventNotifyControl ProcessEvent(const TESTrackedStatsEvent& a_event, BSTEventSource<TESTrackedStatsEvent>* a_source);  // 01
+
+		virtual void Populate(bool a_arg1) override;  // 02
+		virtual void DoClearData() override;          // 03
+		virtual void DoClearSink() override;          // 04
+
+		// members
+		PipboyArray*                             statTypeArray;  // A0
+		BSTHashMap<BSFixedString, PipboyObject*> statMap;        // A8
+	};
+	static_assert(sizeof(PipboyLogData) == 0xD8);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyLogMenu.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyLogMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyLogMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyLogMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyLogMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyLogMenu::UpdateData };
+			return func(this);
+		}
+	};
+	static_assert(sizeof(PipboyLogMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyManager.h

@@ -0,0 +1,262 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSInputEventUser.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTPoint.h"
+#include "RE/B/BSTSingleton.h"
+#include "RE/I/Inventory3DManager.h"
+#include "RE/I/InventoryInterface.h"
+#include "RE/I/IsPipboyActiveEvent.h"
+#include "RE/N/NiPointer.h"
+#include "RE/N/NiRect.h"
+#include "RE/P/PipboyRadioController.h"
+
+namespace RE
+{
+	class BSTriShape;
+	class IMenu;
+	class BSAnimationGraphEvent;
+
+	class __declspec(novtable) PipboyManager :
+		public BSTEventSink<BSAnimationGraphEvent>,  // 00
+		public BSInputEventUser,                     // 08
+		public BSTSingletonSDM<PipboyManager>        // 18
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyManager };
+		static constexpr auto VTABLE{ VTABLE::PipboyManager };
+
+		enum class LOWER_REASON
+		{
+			kNone = 0x0,
+			kBook = 0x1,
+			kPerkGrid = 0x2,
+			kInspect = 0x3
+		};
+
+		enum class PipboyScreenEffectTriggerType
+		{
+			kPipboyOpen = 0x0,
+			kTabChange = 0x1,
+			kCategoryChange = 0x2,
+			kSmallTransition = 0x3,
+			kMapChange = 0x4
+		};
+
+		virtual ~PipboyManager();  // 00
+
+		// override
+		virtual BSEventNotifyControl ProcessEvent(const BSAnimationGraphEvent& a_event, BSTEventSource<BSAnimationGraphEvent>* a_source) override;  // 01
+		virtual bool                 ShouldHandleEvent(const InputEvent*) override;                                                                 // 02
+		virtual void                 OnButtonEvent(const ButtonEvent*) override;                                                                    // 09
+		virtual void                 OnMouseMoveEvent(const MouseMoveEvent*) override;                                                              // 07
+		virtual void                 OnThumbstickEvent(const ThumbstickEvent*) override;                                                            // 05
+
+		[[nodiscard]] static PipboyManager* GetSingleton()
+		{
+			static REL::Relocation<PipboyManager**> singleton{ ID::PipboyManager::Singleton };
+			return *singleton;
+		}
+
+		void AddMenuToPipboy(IMenu& a_menu, const NiRect<float>& a_standVP, const NiRect<float>& a_powerVP)
+		{
+			using func_t = decltype(&PipboyManager::AddMenuToPipboy);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::AddMenuToPipboy };
+			func(this, a_menu, a_standVP, a_powerVP);
+		}
+
+		void ClosedownPipboy()
+		{
+			using func_t = decltype(&PipboyManager::ClosedownPipboy);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::ClosedownPipboy };
+			func(this);
+		}
+
+		void EnablePipboyShader()
+		{
+			using func_t = decltype(&PipboyManager::EnablePipboyShader);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::EnablePipboyShader };
+			func(this);
+		}
+
+		void InitPipboy()
+		{
+			using func_t = decltype(&PipboyManager::InitPipboy);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::InitPipboy };
+			func(this);
+		}
+
+		void LowerPipboy(LOWER_REASON a_reason)
+		{
+			using func_t = decltype(&PipboyManager::LowerPipboy);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::LowerPipboy };
+			func(this, a_reason);
+		}
+
+		void OnPipboyCloseAnim()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyCloseAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::OnPipboyCloseAnim };
+			func(this);
+		}
+
+		void OnPipboyCloseAnimFailed()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyCloseAnimFailed);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::OnPipboyCloseAnimFailed };
+			func(this);
+		}
+
+		void OnPipboyClosed()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyClosed);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::OnPipboyClosed };
+			func(this);
+		}
+
+		void OnPipboyOpenAnim()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyOpenAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::OnPipboyOpenAnim };
+			func(this);
+		}
+
+		void OnPipboyOpenAnimFailed()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyOpenAnimFailed);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::OnPipboyOpenAnimFailed };
+			func(this);
+		}
+
+		void OnPipboyOpened()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyOpened);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::OnPipboyOpened };
+			func(this);
+		}
+
+		void PlayItemAnimOnClose()
+		{
+			using func_t = decltype(&PipboyManager::PlayItemAnimOnClose);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::PlayItemAnimOnClose };
+			func(this);
+		}
+
+		void PlayPipboyCloseAnim(bool a_noAnim)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyCloseAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::PlayPipboyCloseAnim };
+			func(this, a_noAnim);
+		}
+
+		void PlayPipboyGenericOpenAnim(const BSFixedString& a_menu, const BSFixedString& a_anim, bool a_noAnim)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyGenericOpenAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::PlayPipboyGenericOpenAnim };
+			func(this, a_menu, a_anim, a_noAnim);
+		}
+
+		void PlayPipboyLoadHolotapeAnim(BGSNote* a_holotape, bool a_noAnim)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyLoadHolotapeAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::PlayPipboyLoadHolotapeAnim };
+			func(this, a_holotape, a_noAnim);
+		}
+
+		void PlayPipboyOpenAnim(const BSFixedString& a_menuName)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyOpenAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::PlayPipboyOpenAnim };
+			func(this, a_menuName);
+		}
+
+		void PlayPipboyOpenTerminalAnim(BGSTerminal* a_terminal)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyOpenTerminalAnim);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::PlayPipboyOpenTerminalAnim };
+			func(this, a_terminal);
+		}
+
+		void ProcessLoweringReason()
+		{
+			using func_t = decltype(&PipboyManager::ProcessLoweringReason);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::ProcessLoweringReason };
+			func(this);
+		}
+
+		bool QPipboyActive()
+		{
+			using func_t = decltype(&PipboyManager::QPipboyActive);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::QPipboyActive };
+			return func(this);
+		}
+
+		void RaisePipboy()
+		{
+			using func_t = decltype(&PipboyManager::RaisePipboy);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::RaisePipboy };
+			func(this);
+		}
+
+		void RefreshPipboyRenderSurface()
+		{
+			using func_t = decltype(&PipboyManager::RefreshPipboyRenderSurface);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::RefreshPipboyRenderSurface };
+			func(this);
+		}
+
+		void StartAnimationGraphListening()
+		{
+			using func_t = decltype(&PipboyManager::StartAnimationGraphListening);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::StartAnimationGraphListening };
+			func(this);
+		}
+
+		void StopAnimationGraphListening()
+		{
+			using func_t = decltype(&PipboyManager::StopAnimationGraphListening);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::StopAnimationGraphListening };
+			func(this);
+		}
+
+		void UpdateCursorConstraint(bool a_enable)
+		{
+			using func_t = decltype(&PipboyManager::UpdateCursorConstraint);
+			static REL::Relocation<func_t> func{ ID::PipboyManager::UpdateCursorConstraint };
+			func(this, a_enable);
+		}
+
+		// members
+		BSSoundHandle                             pipboyHumSound;          // 01C
+		BSTPoint2<float>                          inputVector;             // 024
+		BSTPoint2<float>                          newInput;                // 02C
+		NiPointer<BSTriShape>                     debugModeGeom;           // 038
+		Inventory3DManager                        inv3DModelManager;       // 040
+		BGSNote*                                  holotapeToLoad;          // 180
+		BGSTerminal*                              terminalToLoad;          // 188
+		BSFixedString                             menuToOpen;              // 190
+		BSFixedString                             openAnimEvent;           // 198
+		BSFixedString                             closeAnimEvent;          // 1A0
+		REX::TEnumSet<LOWER_REASON, std::int32_t> loweringReason;          // 1A8
+		PipboyRadioController                     radioController;         // 1AC
+		TESBoundObject*                           itemAnimOnClose;         // 1B0
+		ObjectRefHandle                           fastTravelLocation;      // 1B8
+		InventoryInterface::Handle                inspectRequestItem;      // 1BC
+		std::uint32_t                             inspectRequestStack;     // 1C0
+		bool                                      pipboyExamineMode;       // 1C4
+		bool                                      pipboyExamineDirtyFlag;  // 1C5
+		bool                                      pipboyOpening;           // 1C6
+		bool                                      pipboyClosing;           // 1C7
+		BSTValueEventSource<IsPipboyActiveEvent>  pipboyActive;            // 1C8
+		bool                                      ignoreOpeningFlag;       // 1E0
+		bool                                      autoSaveOnClose;         // 1E1
+		bool                                      pipboyMenuCloseQueued;   // 1E2
+		bool                                      pipboyRaising;           // 1E3
+		bool                                      wasMotionBlurActive;     // 1E4
+		bool                                      wasPipboyLightActive;    // 1E5
+	};
+	static_assert(sizeof(PipboyManager) == 0x1F0);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyMapData.h

@@ -0,0 +1,107 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	class BGSActorCellEvent;
+	class MapMarkerData;
+	class PlayerUpdateEvent;
+	class TESLocationClearedEvent;
+
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent;
+	}
+
+	namespace CustomMarkerUpdate
+	{
+		class Event;
+	}
+
+	namespace LocalMapCameraUpdate
+	{
+		class Event;
+	}
+
+	namespace LocationMarkerArrayUpdate
+	{
+		class Event;
+	}
+
+	namespace PlayerCharacterQuestEvent
+	{
+		class Event;
+	}
+
+	namespace TESQuestEvent
+	{
+		class Event;
+	}
+
+	namespace TravelMarkerStateChange
+	{
+		class Event;
+	}
+
+	class __declspec(novtable) PipboyMapData :
+		public PipboyDataGroup,                                        // 00
+		public BSTEventSink<TravelMarkerStateChange::Event>,           // 98
+		public BSTEventSink<PlayerUpdateEvent>,                        // A0
+		public BSTEventSink<BGSActorCellEvent>,                        // A8
+		public BSTEventSink<TESQuestEvent::Event>,                     // B0
+		public BSTEventSink<PlayerCharacterQuestEvent::Event>,         // B8
+		public BSTEventSink<CustomMarkerUpdate::Event>,                // C0
+		public BSTEventSink<LocationMarkerArrayUpdate::Event>,         // C8
+		public BSTEventSink<LocalMapCameraUpdate::Event>,              // D0
+		public BSTEventSink<TESLocationClearedEvent>,                  // D8
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>  // E0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyMapData };
+		static constexpr auto VTABLE{ VTABLE::PipboyMapData };
+
+		virtual ~PipboyMapData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const TravelMarkerStateChange::Event& a_event, BSTEventSource<TravelMarkerStateChange::Event>* a_source);                      // 01
+		virtual BSEventNotifyControl ProcessEvent(const PlayerUpdateEvent& a_event, BSTEventSource<PlayerUpdateEvent>* a_source);                                                // 02
+		virtual BSEventNotifyControl ProcessEvent(const BGSActorCellEvent& a_event, BSTEventSource<BGSActorCellEvent>* a_source);                                                // 03
+		virtual BSEventNotifyControl ProcessEvent(const TESQuestEvent::Event& a_event, BSTEventSource<TESQuestEvent::Event>* a_source);                                          // 04
+		virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource<PlayerCharacterQuestEvent::Event>* a_source);                  // 05
+		virtual BSEventNotifyControl ProcessEvent(const CustomMarkerUpdate::Event& a_event, BSTEventSource<CustomMarkerUpdate::Event>* a_source);                                // 06
+		virtual BSEventNotifyControl ProcessEvent(const LocationMarkerArrayUpdate::Event& a_event, BSTEventSource<LocationMarkerArrayUpdate::Event>* a_source);                  // 07
+		virtual BSEventNotifyControl ProcessEvent(const LocalMapCameraUpdate::Event& a_event, BSTEventSource<LocalMapCameraUpdate::Event>* a_source);                            // 08
+		virtual BSEventNotifyControl ProcessEvent(const TESLocationClearedEvent& a_event, BSTEventSource<TESLocationClearedEvent>* a_source);                                    // 09
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 0A
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 0B
+		virtual void DoClearData() override;          // 0C
+		virtual void DoClearSink() override;          // 0D
+
+		// members
+		PipboyObject*                                   mapObject;                   // E8
+		BSTHashMap<const MapMarkerData*, PipboyObject*> travelLocationsMarkers;      // F0
+		BSTHashMap<std::uint32_t, ObjectRefHandle>      travelLocationRefrHandles;   // 120
+		BSTArray<PipboyObject*>                         doorMarkers;                 // 150
+		BSTArray<ObjectRefHandle>                       doorRefHandles;              // 168
+		BSTHashMap<ObjectRefHandle, PipboyObject*>      localQuestMarkers;           // 180
+		BSTHashMap<ObjectRefHandle, PipboyObject*>      worldQuestMarkers;           // 1B0
+		NiPoint3                                        playerLastLocationPosition;  // 1E0
+		NiPoint3                                        playerLastWorldPosition;     // 1EC
+		PipboyObject*                                   localPlayerMarker;           // 1F8
+		PipboyObject*                                   worldPlayerMarker;           // 200
+		PipboyObject*                                   localCustomMarker;           // 208
+		PipboyObject*                                   worldCustomMarker;           // 210
+		PipboyObject*                                   localPowerArmorMarker;       // 218
+		PipboyObject*                                   worldPowerArmorMarker;       // 220
+		PipboyObject*                                   worldMapExtents;             // 230
+		PipboyObject*                                   localMapExtents;             // 238
+	};
+	static_assert(sizeof(PipboyMapData) == 0x238);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyMapMenu.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "RE/B/BSScaleformExternalTexture.h"
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyMapMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyMapMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyMapMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyMapMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyMapMenu::UpdateData };
+			return func(this);
+		}
+
+		// members
+		BSScaleformExternalTexture worldMapTexture;                 // 18
+		Scaleform::GFx::Value      mapPageObj;                      // 30
+		std::uint32_t              centeredQuestMarkerID;           // 50
+		std::uint32_t              centeredMapMarkerID;             // 54
+		std::uint32_t              queuedFastTravelId;              // 58
+		bool                       mapTexturesSentToMenu;           // 5C
+		bool                       requestedDelayedLocalMapRender;  // 5D
+	};
+	static_assert(sizeof(PipboyMapMenu) == 0x60);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyMenu.h

@@ -0,0 +1,57 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/G/GameMenuBase.h"
+#include "RE/P/PipboyInventoryMenu.h"
+#include "RE/P/PipboyLogMenu.h"
+#include "RE/P/PipboyMapMenu.h"
+#include "RE/P/PipboyPerksMenu.h"
+#include "RE/P/PipboyPlayerInfoMenu.h"
+#include "RE/P/PipboyQuestMenu.h"
+#include "RE/P/PipboyRadioMenu.h"
+#include "RE/P/PipboySpecialMenu.h"
+#include "RE/P/PipboyStatsMenu.h"
+#include "RE/P/PipboyWorkshopMenu.h"
+
+namespace RE
+{
+	class IdleInputEvent;
+	class MenuOpenCloseEvent;
+
+	class __declspec(novtable) PipboyMenu :
+		public GameMenuBase,                      // 000
+		public BSTEventSink<MenuOpenCloseEvent>,  // 0E0
+		public BSTEventSink<IdleInputEvent>       // 0E8
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyMenu };
+		static constexpr auto MENU_NAME{ "PipboyMenu"sv };
+
+		void RefreshMapMarkers(std::uint32_t a_markerID)
+		{
+			using func_t = decltype(&PipboyMenu::RefreshMapMarkers);
+			static REL::Relocation<func_t> func{ ID::PipboyMenu::RefreshMapMarkers };
+			return func(this, a_markerID);
+		}
+
+		// members
+		Scaleform::GFx::Value dataObj;                    // 0F0
+		PipboyStatsMenu       statsMenuObj;               // 110
+		PipboySpecialMenu     specialMenuObj;             // 130
+		PipboyPerksMenu       perksMenuObj;               // 148
+		PipboyInventoryMenu   inventoryMenuObj;           // 160
+		PipboyQuestMenu       questMenuObj;               // 178
+		PipboyWorkshopMenu    workshopMenuObj;            // 190
+		PipboyLogMenu         logMenuObj;                 // 1A8
+		PipboyMapMenu         mapMenuObj;                 // 1C0
+		PipboyRadioMenu       radioMenuObj;               // 220
+		PipboyPlayerInfoMenu  playerInfoMenuObj;          // 240
+		std::int8_t           disableInputCounter;        // 258
+		bool                  pipboyCursorEnabled;        // 259
+		bool                  showingModalMessage;        // 25A
+		bool                  pipboyHiddenByAnotherMenu;  // 25B
+		bool                  performFastTravelCheck;     // 25C
+	};
+	static_assert(sizeof(PipboyMenu) == 0x260);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyObject.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/P/PipboyValue.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyObject :
+		public PipboyValue
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyObject };
+		static constexpr auto VTABLE{ VTABLE::PipboyObject };
+
+		virtual ~PipboyObject();  // 00
+
+		// override
+		virtual void                    CleanDirtyToGame() override;                                                        // 01
+		virtual void                    Serialize(Json::Value* a_json) override;                                            // 02
+		virtual void                    SerializeChanges(BSBinarySerializer& a_serializer, bool a_fullSerialize) override;  // 03
+		virtual SERIALIZATION_DATA_TYPE GetType() override;                                                                 // 04
+
+		template <typename T>
+		T GetMember(const BSFixedString& a_name)
+		{
+			const auto it = memberMap.find(a_name);
+			return (it != memberMap.end()) ? static_cast<T>(it->second) : nullptr;
+		}
+
+		void AddMember(const BSFixedString* a_name, PipboyValue* a_member)
+		{
+			using func_t = decltype(&PipboyObject::AddMember);
+			static REL::Relocation<func_t> func{ ID::PipboyObject::AddMember };
+			return func(this, a_name, a_member);
+		}
+
+		// members
+		BSTHashMap<BSFixedString, PipboyValue*> memberMap;         // 18
+		BSTSet<std::uint32_t>                   addedMemberIDs;    // 48
+		BSTArray<std::uint32_t>                 removedMemberIDs;  // 78
+		bool                                    newlyCreated;      // 90
+	};
+	static_assert(sizeof(PipboyObject) == 0x98);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyPerksData.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace PerkValueEvents
+	{
+		class PerkValueChangedEvent;
+	}
+
+	class __declspec(novtable) PipboyPerksData :
+		public PipboyDataGroup,                                      // 00
+		public BSTEventSink<PerkValueEvents::PerkValueChangedEvent>  // 98
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyPerksData };
+		static constexpr auto VTABLE{ VTABLE::PipboyPerksData };
+
+		virtual ~PipboyPerksData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkValueChangedEvent& a_event, BSTEventSource<PerkValueEvents::PerkValueChangedEvent>* a_source);  // 01
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 02
+		virtual void DoClearData() override;          // 03
+		virtual void DoClearSink() override;          // 04
+
+		PipboyArray*             perkChains;      // A0
+		BSTArray<const BGSPerk*> perkChainRoots;  // A8
+		BSTArray<PipboyObject*>  perksArray;      // C0
+	};
+	static_assert(sizeof(PipboyPerksData) == 0xD8);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyPerksMenu.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyPerksMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyPerksMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyPerksMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyPerksMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyPerksMenu::UpdateData };
+			return func(this);
+		}
+	};
+	static_assert(sizeof(PipboyPerksMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyPlayerInfoData.h

@@ -0,0 +1,118 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	class PerkPointIncreaseEvent;
+	class PlayerUpdateEvent;
+
+	namespace ActorEquipManagerEvent
+	{
+		class Event;
+	}
+
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent;
+	}
+
+	namespace BGSInventoryItemEvent
+	{
+		class Event;
+	}
+
+	namespace BGSInventoryListEvent
+	{
+		class Event;
+	}
+
+	namespace HourPassed
+	{
+		class Event;
+	}
+
+	namespace LevelIncrease
+	{
+		class Event;
+	}
+
+	namespace PerkValueEvents
+	{
+		class PerkEntryUpdatedEvent;
+	}
+
+	namespace PlayerActiveEffectChanged
+	{
+		class Event;
+	}
+
+	namespace PlayerCharacterQuestEvent
+	{
+		class Event;
+	}
+
+	namespace PlayerDifficultySettingChanged
+	{
+		class Event;
+	}
+
+	namespace SPECIALMenuEvent
+	{
+		class NameChangedEvent;
+	}
+
+	class __declspec(novtable) PipboyPlayerInfoData :
+		public PipboyDataGroup,                                         // 00
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,  // 98
+		public BSTEventSink<BGSInventoryListEvent::Event>,              // A0
+		public BSTEventSink<ActorEquipManagerEvent::Event>,             // A8
+		public BSTEventSink<LevelIncrease::Event>,                      // B0
+		public BSTEventSink<PerkPointIncreaseEvent>,                    // B8
+		public BSTEventSink<PerkValueEvents::PerkEntryUpdatedEvent>,    // C0
+		public BSTEventSink<HourPassed::Event>,                         // C8
+		public BSTEventSink<SPECIALMenuEvent::NameChangedEvent>,        // D0
+		public BSTEventSink<PlayerUpdateEvent>,                         // D8
+		public BSTEventSink<BGSInventoryItemEvent::Event>,              // E0
+		public BSTEventSink<PlayerActiveEffectChanged::Event>,          // E8
+		public BSTEventSink<PlayerCharacterQuestEvent::Event>,          // F0
+		public BSTEventSink<PlayerDifficultySettingChanged::Event>      // F8
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyPlayerInfoData };
+		static constexpr auto VTABLE{ VTABLE::PipboyPlayerInfoData };
+
+		virtual ~PipboyPlayerInfoData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);                          // 02
+		virtual BSEventNotifyControl ProcessEvent(const ActorEquipManagerEvent::Event& a_event, BSTEventSource<ActorEquipManagerEvent::Event>* a_source);                        // 03
+		virtual BSEventNotifyControl ProcessEvent(const LevelIncrease::Event& a_event, BSTEventSource<LevelIncrease::Event>* a_source);                                          // 04
+		virtual BSEventNotifyControl ProcessEvent(const PerkPointIncreaseEvent& a_event, BSTEventSource<PerkPointIncreaseEvent>* a_source);                                      // 05
+		virtual BSEventNotifyControl ProcessEvent(const PerkValueEvents::PerkEntryUpdatedEvent& a_event, BSTEventSource<PerkValueEvents::PerkEntryUpdatedEvent>* a_source);      // 06
+		virtual BSEventNotifyControl ProcessEvent(const HourPassed::Event& a_event, BSTEventSource<HourPassed::Event>* a_source);                                                // 07
+		virtual BSEventNotifyControl ProcessEvent(const SPECIALMenuEvent::NameChangedEvent& a_event, BSTEventSource<SPECIALMenuEvent::NameChangedEvent>* a_source);              // 08
+		virtual BSEventNotifyControl ProcessEvent(const PlayerUpdateEvent& a_event, BSTEventSource<PlayerUpdateEvent>* a_source);                                                // 09
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource<BGSInventoryItemEvent::Event>* a_source);                          // 0A
+		virtual BSEventNotifyControl ProcessEvent(const PlayerActiveEffectChanged::Event& a_event, BSTEventSource<PlayerActiveEffectChanged::Event>* a_source);                  // 0B
+		virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource<PlayerCharacterQuestEvent::Event>* a_source);                  // 0C
+		virtual BSEventNotifyControl ProcessEvent(const PlayerDifficultySettingChanged::Event& a_event, BSTEventSource<PlayerDifficultySettingChanged::Event>* a_source);        // 0D
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 0E
+		virtual void DoClearData() override;          // 0F
+		virtual void DoClearSink() override;          // 10
+
+		void UpdateCarryWeightData()
+		{
+			using func_t = decltype(&PipboyPlayerInfoData::UpdateCarryWeightData);
+			static REL::Relocation<func_t> func{ ID::PipboyPlayerInfoData::UpdateCarryWeightData };
+			return func(this);
+		}
+
+		// members
+		PipboyObject* playerInfoObject;
+	};
+	static_assert(sizeof(PipboyPlayerInfoData) == 0x108);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyPlayerInfoMenu.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyPlayerInfoMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyPlayerInfoMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyPlayerInfoMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyPlayerInfoMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyPlayerInfoMenu::UpdateData };
+			return func(this);
+		}
+	};
+	static_assert(sizeof(PipboyPlayerInfoMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyPrimitiveValue.h

@@ -0,0 +1,75 @@
+#pragma once
+
+#include "RE/P/PipboyValue.h"
+
+namespace RE
+{
+	template <class T>
+	class PipboyPrimitiveValue;  // Forward declaration for specialization **only**
+
+	template <>
+	class __declspec(novtable) PipboyPrimitiveValue<std::uint32_t> :
+		public PipboyValue
+	{
+	public:
+		virtual ~PipboyPrimitiveValue() {}  // 00
+
+		// override
+		virtual void                    CleanDirtyToGame() override {}                                                                                              // 00
+		virtual void                    Serialize([[maybe_unused]] Json::Value* a_json) override {}                                                                 // 01
+		virtual void                    SerializeChanges([[maybe_unused]] BSBinarySerializer& a_serializer, [[maybe_unused]] bool a_fullSerialization) override {}  // 03
+		virtual SERIALIZATION_DATA_TYPE GetType() override { return SERIALIZATION_DATA_TYPE::kUint32; }
+
+		PipboyPrimitiveValue(std::uint32_t a_value, PipboyValue* a_parentValue) :
+			PipboyValue(a_parentValue), value(a_value) {}
+
+		void ctor(std::uint32_t a_value, PipboyValue* a_parentValue)
+		{
+			using func_t = decltype(&PipboyPrimitiveValue<std::uint32_t>::ctor);
+			static REL::Relocation<func_t> func{ ID::PipboyPrimitiveValue::uint32::ctor };
+			func(this, a_value, a_parentValue);
+		}
+
+		operator std::uint32_t() const
+		{
+			return value;
+		}
+
+		// members
+		std::uint32_t value;  // 18
+	};
+	static_assert(sizeof(PipboyPrimitiveValue<std::uint32_t>) == 0x20);
+
+	template <>
+	class __declspec(novtable) PipboyPrimitiveValue<bool> :
+		public PipboyValue
+	{
+	public:
+		virtual ~PipboyPrimitiveValue() {}  // 00
+
+		// override
+		virtual void                    CleanDirtyToGame() override {}                                                                                              // 00
+		virtual void                    Serialize([[maybe_unused]] Json::Value* a_json) override {}                                                                 // 01
+		virtual void                    SerializeChanges([[maybe_unused]] BSBinarySerializer& a_serializer, [[maybe_unused]] bool a_fullSerialization) override {}  // 03
+		virtual SERIALIZATION_DATA_TYPE GetType() override { return SERIALIZATION_DATA_TYPE::kBool; }
+
+		PipboyPrimitiveValue(bool a_value, PipboyValue* a_parentValue) :
+			PipboyValue(a_parentValue), value(a_value) {}
+
+		void ctor(bool a_value, PipboyValue* a_parentValue)
+		{
+			using func_t = decltype(&PipboyPrimitiveValue<bool>::ctor);
+			static REL::Relocation<func_t> func{ ID::PipboyPrimitiveValue::boolean::ctor };
+			func(this, a_value, a_parentValue);
+		}
+
+		operator bool() const
+		{
+			return value;
+		}
+
+		// members
+		bool value;  // 18
+	};
+	static_assert(sizeof(PipboyPrimitiveValue<bool>) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyQuestData.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace PlayerCharacterQuestEvent
+	{
+		class Event;
+	}
+
+	namespace TESQuestEvent
+	{
+		class Event;
+	}
+
+	class __declspec(novtable) PipboyQuestData :
+		public PipboyDataGroup,                                 // 00
+		public BSTEventSink<PlayerCharacterQuestEvent::Event>,  // 89
+		public BSTEventSink<TESQuestEvent::Event>               // A0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyQuestData };
+		static constexpr auto VTABLE{ VTABLE::PipboyQuestData };
+
+		virtual ~PipboyQuestData();
+
+		virtual BSEventNotifyControl ProcessEvent(const PlayerCharacterQuestEvent::Event& a_event, BSTEventSource<PlayerCharacterQuestEvent::Event>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const TESQuestEvent::Event& a_event, BSTEventSource<TESQuestEvent::Event>* a_source);                          // 02
+
+		virtual void Populate(bool a_arg1) override;  // 03
+		virtual void DoClearData() override;          // 04
+		virtual void DoClearSink() override;          // 05
+
+		// members
+		std::uint32_t sortIndex;             // A8
+		PipboyArray*  questArray;            // B0
+		void*         objectivesByQuest[6];  // B8 - BSTHashMap<BSTTuple<TESQuest*, std::uint64_t>, BSTArray<BGSInstancedQuestObjective>*>
+	};
+	static_assert(sizeof(PipboyQuestData) == 0xE8);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyQuestMenu.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyQuestMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyQuestMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyQuestMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyQuestMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyQuestMenu::UpdateData };
+			return func(this);
+		}
+	};
+	static_assert(sizeof(PipboyQuestMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyRadioController.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	class PipboyRadioController
+	{
+	public:
+		// members
+		float chaseStation;  // 00
+	};
+	static_assert(sizeof(PipboyRadioController) == 0x04);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyRadioData.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace RadioManager
+	{
+		class PipboyFrequencyDetectionEvent;
+		class PipboyRadioTuningEvent;
+	}
+
+	class __declspec(novtable) PipboyRadioData :
+		public PipboyDataGroup,                                            // 00
+		public BSTEventSink<RadioManager::PipboyFrequencyDetectionEvent>,  // 98
+		public BSTEventSink<RadioManager::PipboyRadioTuningEvent>          // A0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyRadioData };
+		static constexpr auto VTABLE{ VTABLE::PipboyRadioData };
+
+		virtual ~PipboyRadioData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const RadioManager::PipboyFrequencyDetectionEvent& a_event, BSTEventSource<RadioManager::PipboyFrequencyDetectionEvent>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const RadioManager::PipboyRadioTuningEvent& a_event, BSTEventSource<RadioManager::PipboyRadioTuningEvent>* a_source);                // 02
+
+		virtual void Populate(bool a_arg1) override;  // 03
+		virtual void DoClearData() override;          // 04
+		virtual void DoClearSink() override;          // 05
+
+		// members
+		PipboyArray* radioStations;  // A8
+	};
+	static_assert(sizeof(PipboyRadioData) == 0xB0);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyRadioMenu.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyRadioMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyRadioMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyRadioMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyRadioMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyRadioMenu::UpdateData };
+			return func(this);
+		}
+
+		bool radioModeOn;  // 18
+	};
+	static_assert(sizeof(PipboyRadioMenu) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/P/PipboySpecialData.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent;
+	}
+
+	class __declspec(novtable) PipboySpecialData :
+		public PipboyDataGroup,                                        // 00
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>  // 98
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboySpecialData };
+		static constexpr auto VTABLE{ VTABLE::PipboySpecialData };
+
+		virtual ~PipboySpecialData();
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 01
+		virtual void DoClearData() override;          // 02
+		virtual void DoClearSink() override;          // 03
+
+		// add
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 04
+
+		// members
+		PipboyArray* specialsArray;  // A0
+	};
+	static_assert(sizeof(PipboySpecialData) == 0xA8);
+}

plugin/lib/commonlibf4/include/RE/P/PipboySpecialMenu.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboySpecialMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboySpecialMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboySpecialMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboySpecialMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboySpecialMenu::UpdateData };
+			return func(this);
+		}
+	};
+	static_assert(sizeof(PipboySpecialMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyStatsData.h

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	class ConditionBoyEvent;
+
+	namespace ActorItemEquipped
+	{
+		class Event;
+	}
+
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent;
+	}
+
+	namespace BGSInventoryItemEvent
+	{
+		class Event;
+	}
+
+	namespace BGSInventoryListEvent
+	{
+		class Event;
+	}
+
+	namespace PlayerActiveEffectChanged
+	{
+		class Event;
+	}
+
+	class __declspec(novtable) PipboyStatsData :
+		public PipboyDataGroup,                                         // 00
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,  // 98
+		public BSTEventSink<BGSInventoryListEvent::Event>,              // A0
+		public BSTEventSink<PlayerActiveEffectChanged::Event>,          // A8
+		public BSTEventSink<ConditionBoyEvent>,                         // B0
+		public BSTEventSink<ActorItemEquipped::Event>,                  // B8
+		public BSTEventSink<BGSInventoryItemEvent::Event>               // C0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyStatsData };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatsData };
+
+		virtual ~PipboyStatsData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);                          // 02
+		virtual BSEventNotifyControl ProcessEvent(const PlayerActiveEffectChanged::Event& a_event, BSTEventSource<PlayerActiveEffectChanged::Event>* a_source);                  // 03
+		virtual BSEventNotifyControl ProcessEvent(const ConditionBoyEvent& a_event, BSTEventSource<ConditionBoyEvent>* a_source);                                                // 04
+		virtual BSEventNotifyControl ProcessEvent(const ActorItemEquipped::Event& a_event, BSTEventSource<ActorItemEquipped::Event>* a_source);                                  // 05
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryItemEvent::Event& a_event, BSTEventSource<BGSInventoryItemEvent::Event>* a_source);                          // 06
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 07
+		virtual void DoClearData() override;          // 08
+		virtual void DoClearSink() override;          // 09
+
+		// members
+		PipboyObject*                                            playerStatsObject;       // C8
+		PipboyArray*                                             activeEffectsArray;      // D0
+		BSTHashMap<MagicItem*, PipboyObject*>                    activeEffectsMap;        // D8
+		BSTHashMap<BSTSmartPointer<ActiveEffect>, PipboyObject*> activeEffectEntriesMap;  // 108
+	};
+	static_assert(sizeof(PipboyStatsData) == 0x138);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyStatsMenu.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "RE/B/BSSoundHandle.h"
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyStatsMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyStatsMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatsMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyStatsMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyStatsMenu::UpdateData };
+			return func(this);
+		}
+
+		// members
+		BSSoundHandle perkSound;  // 18
+	};
+	static_assert(sizeof(PipboyStatsMenu) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyStatusData.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	class MenuOpenCloseEvent;
+	class UserEventEnabledEvent;
+
+	namespace BGSInventoryListEvent
+	{
+		class Event;
+	}
+
+	namespace LoadingStatusChanged
+	{
+		class Event;
+	}
+
+	namespace PlayerInDialogueChanged
+	{
+		class Event;
+	}
+
+	namespace PlayerLifeStateChanged
+	{
+		class Event;
+	}
+
+	namespace VATSEvents
+	{
+		class ModeChange;
+	}
+
+	class __declspec(novtable) PipboyStatusData :
+		public PipboyDataGroup,                               // 00
+		public BSTEventSink<PlayerLifeStateChanged::Event>,   // 98
+		public BSTEventSink<PlayerInDialogueChanged::Event>,  // A0
+		public BSTEventSink<MenuOpenCloseEvent>,              // A8
+		public BSTEventSink<BGSInventoryListEvent::Event>,    // B0
+		public BSTEventSink<LoadingStatusChanged::Event>,     // B8
+		public BSTEventSink<VATSEvents::ModeChange>,          // C0
+		public BSTEventSink<UserEventEnabledEvent>            // C8
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyStatusData };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatusData };
+
+		virtual ~PipboyStatusData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const PlayerLifeStateChanged::Event& a_event, BSTEventSource<PlayerLifeStateChanged::Event>* a_source);    // 01
+		virtual BSEventNotifyControl ProcessEvent(const PlayerInDialogueChanged::Event& a_event, BSTEventSource<PlayerInDialogueChanged::Event>* a_source);  // 02
+		virtual BSEventNotifyControl ProcessEvent(const MenuOpenCloseEvent& a_event, BSTEventSource<MenuOpenCloseEvent>* a_source);                          // 03
+		virtual BSEventNotifyControl ProcessEvent(const BGSInventoryListEvent::Event& a_event, BSTEventSource<BGSInventoryListEvent::Event>* a_source);      // 04
+		virtual BSEventNotifyControl ProcessEvent(const LoadingStatusChanged::Event& a_event, BSTEventSource<LoadingStatusChanged::Event>* a_source);        // 05
+		virtual BSEventNotifyControl ProcessEvent(const VATSEvents::ModeChange& a_event, BSTEventSource<VATSEvents::ModeChange>* a_source);                  // 06
+		virtual BSEventNotifyControl ProcessEvent(const UserEventEnabledEvent& a_event, BSTEventSource<UserEventEnabledEvent>* a_source);                    // 07
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 08
+		virtual void DoClearData() override;          // 09
+		virtual void DoClearSink() override;          // 0A
+
+		// members
+		PipboyObject* statusObject;
+		PipboyArray*  pipboyEffectColorArray;
+	};
+	static_assert(sizeof(PipboyStatusData) == 0xE0);
+}

plugin/lib/commonlibf4/include/RE/P/PipboySubMenu.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "Scaleform/G/GFx_Value.h"
+
+namespace RE
+{
+	class PipboyValueChangedEvent;
+
+	class __declspec(novtable) PipboySubMenu :
+		public BSTEventSink<PipboyValueChangedEvent>  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboySubMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboySubMenu };
+
+		// override (BSTEventSink<PipboyValueChangedEvent>)
+		BSEventNotifyControl ProcessEvent(const PipboyValueChangedEvent& a_event, BSTEventSource<PipboyValueChangedEvent>* a_source) override
+		{
+			using func_t = decltype(&PipboySubMenu::ProcessEvent);
+			static REL::Relocation<func_t> func{ ID::PipboySubMenu::ProcessEvent };
+			return func(this, a_event, a_source);
+		}
+
+		// add
+		virtual void UpdateData() = 0;  // 02
+
+		// members
+		Scaleform::GFx::Value* dataObj;  // 08
+		Scaleform::GFx::Value* menuObj;  // 10
+	};
+	static_assert(sizeof(PipboySubMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyThrottleManager.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/B/BSTHashMap.h"
+#include "RE/I/IPipboyThrottledValue.h"
+
+namespace RE
+{
+	class PipboyThrottleManager
+	{
+	public:
+		BSTHashMap<std::uint32_t, IPipboyThrottledValue*> valueMap;  // 00
+	};
+	static_assert(sizeof(PipboyThrottleManager) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyValue.h

@@ -0,0 +1,58 @@
+#pragma once
+
+namespace Json
+{
+	class Value;
+}
+
+namespace RE
+{
+	class BSBinarySerializer;
+
+	class __declspec(novtable) PipboyValue
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyValue };
+		static constexpr auto VTABLE{ VTABLE::PipboyValue };
+
+		enum SERIALIZATION_DATA_TYPE : std::uint8_t
+		{
+			kBool = 0x0,
+			kInt8 = 0x1,
+			kUint8 = 0x2,
+			kInt32 = 0x3,
+			kUint32 = 0x4,
+			kFloat = 0x5,
+			kString = 0x6,
+			kArray = 0x7,
+			kObject = 0x8,
+		};
+
+		virtual ~PipboyValue() = default;  // 00
+
+		// add
+		virtual void                    CleanDirtyToGame();                                                        // 01
+		virtual void                    Serialize(Json::Value* a_json) = 0;                                        // 02
+		virtual void                    SerializeChanges(BSBinarySerializer& a_serializer, bool a_fullSerialize);  // 03
+		virtual SERIALIZATION_DATA_TYPE GetType() = 0;                                                             // 04
+
+		PipboyValue(PipboyValue* a_parentValue)
+		{
+			ctor(a_parentValue);
+		};
+
+		void ctor(PipboyValue* a_parentValue)
+		{
+			using func_t = decltype(&PipboyValue::ctor);
+			static REL::Relocation<func_t> func{ ID::PipboyValue::ctor };
+			return func(this, a_parentValue);
+		}
+
+		// members
+		std::uint32_t id;                  // 08
+		bool          isDirtyGame;         // 0C
+		bool          isDirtyToCompanion;  // 0D
+		PipboyValue*  parentValue;         // 10
+	};
+	static_assert(sizeof(PipboyValue) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyWorkshopData.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/P/PipboyDataGroup.h"
+
+namespace RE
+{
+	namespace ActorValueEvents
+	{
+		class ActorValueChangedEvent;
+	}
+
+	namespace Workshop
+	{
+		class WorkshopModeEvent;
+	}
+
+	class __declspec(novtable) PipboyWorkshopData :
+		public PipboyDataGroup,
+		public BSTEventSink<ActorValueEvents::ActorValueChangedEvent>,
+		public BSTEventSink<Workshop::WorkshopModeEvent>
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyWorkshopData };
+		static constexpr auto VTABLE{ VTABLE::PipboyStatusData };
+
+		virtual ~PipboyWorkshopData() = default;
+
+		virtual BSEventNotifyControl ProcessEvent(const ActorValueEvents::ActorValueChangedEvent& a_event, BSTEventSource<ActorValueEvents::ActorValueChangedEvent>* a_source);  // 01
+		virtual BSEventNotifyControl ProcessEvent(const Workshop::WorkshopModeEvent& a_event, BSTEventSource<Workshop::WorkshopModeEvent>* a_source);                            // 02
+
+		// override
+		virtual void Populate(bool a_arg1) override;  // 03
+		virtual void DoClearData() override;          // 04
+		virtual void DoClearSink() override;          // 05
+
+		// members
+		PipboyArray*                               workshopArray;          // A8
+		BSTHashMap<std::uint32_t, PipboyObject*>   workshopMap;            // B0
+		BSTHashMap<BSFixedStringCS, std::int32_t>  ratingUpdateFunctions;  // E0
+		BSTHashMap<BSFixedStringCS, std::uint32_t> getValueFunctions;      // 110
+	};
+	static_assert(sizeof(PipboyWorkshopData) == 0x140);
+}

plugin/lib/commonlibf4/include/RE/P/PipboyWorkshopMenu.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/P/PipboySubMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PipboyWorkshopMenu :
+		public PipboySubMenu  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PipboyWorkshopMenu };
+		static constexpr auto VTABLE{ VTABLE::PipboyWorkshopMenu };
+
+		// override (PipboySubMenu)
+		void UpdateData() override
+		{
+			using func_t = decltype(&PipboyWorkshopMenu::UpdateData);
+			static REL::Relocation<func_t> func{ ID::PipboyWorkshopMenu::UpdateData };
+			return func(this);
+		}
+	};
+	static_assert(sizeof(PipboyWorkshopMenu) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerActiveEffectChanged.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSTSmartPointer.h"
+
+namespace RE
+{
+	namespace PlayerActiveEffectChanged
+	{
+		enum Status : std::int32_t
+		{
+			kAdded = 0x0,
+			kRemoved = 0x1,
+			kStatusChanged = 0x2
+		};
+
+		class Event
+		{
+		public:
+			// members
+			BSTSmartPointer<ActiveEffect, BSTSmartPointerIntrusiveRefCount> effect;  // 00
+			PlayerActiveEffectChanged::Status                               status;  // 08
+		};
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PlayerAddicted.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	namespace PlayerAddicted
+	{
+		class Event
+		{
+		public:
+			// members
+			const AlchemyItem* chem;  // 00
+		};
+		static_assert(sizeof(Event) == 0x8);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PlayerAmmoCountEvent.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+#include "RE/P/PlayerAmmoCounts.h"
+
+namespace RE
+{
+	class PlayerAmmoCountEvent :
+		public BSTValueEvent<PlayerAmmoCounts>
+	{
+	public:
+	};
+	static_assert(sizeof(PlayerAmmoCountEvent) == 0xC);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerAmmoCounts.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	class PlayerAmmoCounts
+	{
+	public:
+		// members
+		std::uint32_t clipAmmo;     // 00
+		std::uint32_t reserveAmmo;  // 04
+	};
+	static_assert(sizeof(PlayerAmmoCounts) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerAutoAimActorEvent.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class PlayerAutoAimActorEvent :
+		public BSTValueEvent<ActorHandle>  // 0
+	{
+	public:
+	};
+	static_assert(sizeof(PlayerAutoAimActorEvent) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerCamera.h

@@ -0,0 +1,154 @@
+#pragma once
+
+#include "RE/B/BSInputEventReceiver.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTSingleton.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/C/CameraStates.h"
+#include "RE/H/hknpBodyId.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/T/TESCamera.h"
+#include "RE/T/TESCameraState.h"
+
+namespace RE
+{
+	class hknpBSWorld;
+	class hknpShape;
+	class IdleInputEvent;
+	class OtherEventEnabledEvent;
+	class UserEventEnabledEvent;
+
+	class __declspec(novtable) PlayerCamera :
+		public TESCamera,                             // 000
+		public BSInputEventReceiver,                  // 038
+		public BSTEventSink<IdleInputEvent>,          // 048
+		public BSTEventSink<UserEventEnabledEvent>,   // 050
+		public BSTEventSink<OtherEventEnabledEvent>,  // 058
+		public BSTSingletonSDM<PlayerCamera>          // 060
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PlayerCamera };
+		static constexpr auto VTABLE{ VTABLE::PlayerCamera };
+
+		[[nodiscard]] static PlayerCamera* GetSingleton()
+		{
+			static REL::Relocation<PlayerCamera**> singleton{ ID::PlayerCamera::Singleton };
+			return *singleton;
+		}
+
+		[[nodiscard]] BSTSmartPointer<TESCameraState> GetCameraCurrentState() const
+		{
+			return currentState;
+		}
+
+		bool GetCameraPosition(NiPoint3& a_position, bool a_addPlayerPos) const
+		{
+			using func_t = decltype(&PlayerCamera::GetCameraPosition);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::GetCameraPosition };
+			return func(this, a_position, a_addPlayerPos);
+		}
+
+		[[nodiscard]] BSTSmartPointer<TESCameraState> GetState(CameraState a_state) const
+		{
+			return cameraStates[a_state];
+		}
+
+		template <class T>
+		[[nodiscard]] BSTSmartPointer<T> GetState() const
+			requires(std::derived_from<T, TESCameraState>)
+		{
+			return BSTSmartPointer{ static_cast<T*>(cameraStates[T::STATE].get()) };
+		}
+
+		TESCameraState* PopState()
+		{
+			using func_t = decltype(&PlayerCamera::PopState);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::PopState };
+			return func(this);
+		}
+
+		TESCameraState* PushState(CameraState a_state)
+		{
+			using func_t = decltype(&PlayerCamera::PushState);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::PushState };
+			return func(this, a_state);
+		}
+
+		void ToggleFreeCameraMode(bool a_freezeTime)
+		{
+			using func_t = decltype(&PlayerCamera::ToggleFreeCameraMode);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::ToggleFreeCameraMode };
+			return func(this, a_freezeTime);
+		}
+
+		void SetState(TESCameraState* a_newstate)
+		{
+			using func_t = decltype(&PlayerCamera::SetState);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::SetState };
+			return func(this, a_newstate);
+		}
+
+		void StartFurnitureMode(TESObjectREFR* a_furniture)
+		{
+			using func_t = decltype(&PlayerCamera::StartFurnitureMode);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::StartFurnitureMode };
+			return func(this, a_furniture);
+		}
+
+		void StartPipboyMode(bool a_forcePipboyModeCamera)
+		{
+			using func_t = decltype(&PlayerCamera::StartPipboyMode);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::StartPipboyMode };
+			return func(this, a_forcePipboyModeCamera);
+		}
+
+		void StopPipboyMode()
+		{
+			using func_t = decltype(&PlayerCamera::StopPipboyMode);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::StopPipboyMode };
+			return func(this);
+		}
+
+		bool QCameraEquals(CameraState a_state) const
+		{
+			using func_t = decltype(&PlayerCamera::QCameraEquals);
+			static REL::Relocation<func_t> func{ ID::PlayerCamera::QCameraEquals };
+			return func(this, a_state);
+		}
+
+		// members
+		ActorHandle                                                          cameraTarget;                        // 064
+		BSTSmallArray<BSTSmartPointer<TESCameraState>, CameraStates::kTotal> tempReturnStates;                    // 068
+		BSTSmartPointer<TESCameraState>                                      cameraStates[CameraStates::kTotal];  // 0E0
+		hknpBodyId                                                           cameraBodyID;                        // 148
+		hkRefPtr<hknpShape>                                                  cameraShape;                         // 150
+		hkRefPtr<hknpBSWorld>                                                physicsWorld;                        // 158
+		ActorHandle                                                          savedCollidedActor;                  // 160
+		ObjectRefHandle                                                      collisionIgnoredReference;           // 164
+		float                                                                worldFOV;                            // 168
+		float                                                                firstPersonFOV;                      // 16C
+		float                                                                fovAdjustCurrent;                    // 170
+		float                                                                fovAdjustTarget;                     // 174
+		float                                                                fovAdjustPerSec;                     // 178
+		float                                                                fovAnimatorAdjust;                   // 17C
+		float                                                                collisionDistPercent;                // 180
+		float                                                                curPlayerVisible;                    // 184
+		NiPoint3                                                             bufferedCameraPos;                   // 188
+		float                                                                heading;                             // 194
+		float                                                                timeInPitchZero;                     // 198
+		float                                                                originalPitchToZero;                 // 19C
+		std::uint32_t                                                        furnitureCollisionGroup;             // 1A0
+		bool                                                                 allowAutoVanityMode;                 // 1A4
+		bool                                                                 bowZoomedIn;                         // 1A5
+		bool                                                                 freeRotationReady;                   // 1A6
+		bool                                                                 cameraPosBuffered;                   // 1A7
+		bool                                                                 zeroOutPitch;                        // 1A8
+		bool                                                                 adjustFOV;                           // 1A9
+		bool                                                                 trailerCameraMode;                   // 1AA
+		bool                                                                 pipboyMode;                          // 1AB
+		bool                                                                 savedFadeOutCloseActors;             // 1AC
+	};
+	static_assert(sizeof(PlayerCamera) == 0x1B0);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerCharacter.h

@@ -0,0 +1,537 @@
+#pragma once
+
+#include "RE/A/AITimeStamp.h"
+#include "RE/A/Actor.h"
+#include "RE/B/BGSCharacterTint.h"
+#include "RE/B/BGSEquipIndex.h"
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/B/BSTTuple.h"
+#include "RE/C/CrimeGoldStruct.h"
+#include "RE/D/DifficultyLevel.h"
+#include "RE/F/FriendshipFactionsStruct.h"
+#include "RE/I/IMovementPlayerControlsFilter.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiPointer.h"
+#include "RE/N/NiTMap.h"
+#include "RE/P/PLAYER_TARGET_LOC.h"
+#include "RE/P/PlayerAutoAimActorEvent.h"
+#include "RE/P/PlayerCommandTypeEvent.h"
+#include "RE/P/PlayerCoverData.h"
+#include "RE/S/SCENE_ACTION_PLAYER_RESPONSE_TYPE.h"
+#include "RE/S/SayOnceTimeStampStruct.h"
+#include "RE/S/StolenItemValueStruct.h"
+#include "RE/S/SubgraphHandle.h"
+#include "RE/T/TeleportPath.h"
+#include "RE/X/XPChangeData.h"
+
+namespace RE
+{
+	enum class DEFAULT_OBJECT;
+	enum class PLAYER_ACTION;
+	class BGSActorCellEvent;
+	class BGSActorDeathEvent;
+	class BGSInstancedQuestObjective;
+	class BipedAnim;
+	class BSLight;
+	class BSPathingSolution;
+	class Crime;
+	class EquippedItem;
+	class ImageSpaceModifierInstanceDOF;
+	class ImageSpaceModifierInstanceForm;
+	class ItemChange;
+	class MenuModeChangeEvent;
+	class MenuOpenCloseEvent;
+	class NiAVObject;
+	class NiLight;
+	class NiNode;
+	class OtherEventEnabledEvent;
+	class PickRefUpdateEvent;
+	class PlayerActionObject;
+	class PositionPlayerEvent;
+	class QuestTargetArray;
+	class TESHitEvent;
+	class TESQuestStageItem;
+	class UserEventEnabledEvent;
+
+	namespace PerkValueEvents
+	{
+		class PerkEntryUpdatedEvent;
+	}
+
+	inline bool IsPlayerInDialogue()
+	{
+		using func_t = decltype(&IsPlayerInDialogue);
+		static REL::Relocation<func_t> func{ ID::IsPlayerInDialogue };
+		return func();
+	}
+
+	class __declspec(novtable) PlayerCharacter :
+		public Actor,                                                 // 000
+		public BSTEventSource<BGSActorCellEvent>,                     // 4C8
+		public BSTEventSource<BGSActorDeathEvent>,                    // 520
+		public BSTEventSource<PositionPlayerEvent>,                   // 578
+		public BSTEventSource<PickRefUpdateEvent>,                    // 5D0
+		public BSTEventSink<MenuOpenCloseEvent>,                      // 490
+		public BSTEventSink<MenuModeChangeEvent>,                     // 498
+		public BSTEventSink<UserEventEnabledEvent>,                   // 4A0
+		public BSTEventSink<OtherEventEnabledEvent>,                  // 4A8
+		public BSTEventSink<TESHitEvent>,                             // 4B0
+		public BSTEventSink<PerkValueEvents::PerkEntryUpdatedEvent>,  // 4B8
+		public IMovementPlayerControlsFilter                          // 4C0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PlayerCharacter };
+		static constexpr auto VTABLE{ VTABLE::PlayerCharacter };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kACHR };
+
+		enum class CHAR_GEN_DISABLE_FLAGS
+		{
+			kDisableSave = 0x1,
+			kDisableWait = 0x2,
+			kShowControlsDisabledMessage = 0x4
+		};
+
+		enum class GrabbingType
+		{
+			kNone = 0x0,
+			kNormal = 0x1,
+			kTelekinesis = 0x2
+		};
+
+		enum class PROGRESS_EVENT
+		{
+			kLevelUp = 0x0,
+			kDeath = 0x1,
+			kChargen = 0x2
+		};
+
+		class PlayerActionObject
+		{
+		public:
+			// members
+			float                                      timer;   // 0
+			ObjectRefHandle                            refObj;  // 4
+			REX::TEnumSet<PLAYER_ACTION, std::int32_t> next;    // 8
+		};
+		static_assert(sizeof(PlayerActionObject) == 0xC);
+
+		class ScopedInventoryChangeMessageContext
+		{
+		public:
+			ScopedInventoryChangeMessageContext(bool a_suppressMessages, bool a_suppressAudio) :
+				suppressMessages(a_suppressMessages), suppressAudio(a_suppressAudio)
+			{
+				ctor(suppressMessages, suppressAudio);
+			}
+
+			~ScopedInventoryChangeMessageContext()
+			{
+				dtor();
+			}
+
+			// members
+			const bool suppressMessages{ false };  // 00
+			const bool suppressAudio{ false };     // 01
+
+		private:
+			void ctor(bool a_suppressMessages, bool a_suppressAudio)
+			{
+				using func_t = decltype(&ScopedInventoryChangeMessageContext::ctor);
+				static REL::Relocation<func_t> func{ ID::PlayerCharacter::ScopedInventoryChangeMessageContext::ctor };
+				return func(this, a_suppressMessages, a_suppressAudio);
+			}
+
+			void dtor()
+			{
+				using func_t = decltype(&ScopedInventoryChangeMessageContext::dtor);
+				static REL::Relocation<func_t> func{ ID::PlayerCharacter::ScopedInventoryChangeMessageContext::dtor };
+				return func(this);
+			}
+		};
+		static_assert(sizeof(ScopedInventoryChangeMessageContext) == 0x2);
+
+		// add
+		virtual void          InitiateSpectator(Actor*) { return; }                      // 133
+		virtual std::uint32_t GetViolentCrimeGoldValue(const TESFaction* a_faction);     // 134
+		virtual std::uint32_t GetNonViolentCrimeGoldValue(const TESFaction* a_faction);  // 135
+		virtual void          ClearAllCrimeGold(TESFaction* a_faction);                  // 136
+
+		[[nodiscard]] static PlayerCharacter* GetSingleton()
+		{
+			static REL::Relocation<NiPointer<PlayerCharacter>*> singleton{ ID::PlayerCharacter::Singleton };
+			return singleton->get();
+		}
+
+		[[nodiscard]] static ActorHandle GetPlayerHandle()
+		{
+			static REL::Relocation<ActorHandle*> singleton{ ID::PlayerCharacter::GetPlayerHandle };
+			return *singleton;
+		}
+
+		DifficultyLevel GetDifficultyLevel()
+		{
+			using func_t = decltype(&PlayerCharacter::GetDifficultyLevel);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::GetDifficultyLevel };
+			return func(this);
+		}
+
+		bool IsGodMode()
+		{
+			using func_t = decltype(&PlayerCharacter::IsGodMode);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::IsGodMode };
+			return func(this);
+		}
+
+		bool IsHolotapePlaying(BGSNote* a_holotape)
+		{
+			using func_t = decltype(&PlayerCharacter::IsHolotapePlaying);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::IsHolotapePlaying };
+			return func(this, a_holotape);
+		}
+
+		bool IsImmortal()
+		{
+			using func_t = decltype(&PlayerCharacter::IsImmortal);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::IsImmortal };
+			return func(this);
+		}
+
+		bool IsLockedOutOfTerminal(ObjectRefHandle a_handle);
+
+		bool IsPipboyLightOn()
+		{
+			using func_t = decltype(&PlayerCharacter::IsPipboyLightOn);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::IsPipboyLightOn };
+			return func(this);
+		}
+
+		void LockOutOfTerminal(ObjectRefHandle a_handle);
+
+		void PauseHolotape(BGSNote* a_holotape)
+		{
+			using func_t = decltype(&PlayerCharacter::PauseHolotape);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::PauseHolotape };
+			return func(this, a_holotape);
+		}
+
+		void PlayHolotape(BGSNote* a_holotape)
+		{
+			using func_t = decltype(&PlayerCharacter::PlayHolotape);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::PlayHolotape };
+			return func(this, a_holotape);
+		}
+
+		void QueueFastTravel(ObjectRefHandle a_marker, bool a_allowAutoSave)
+		{
+			using func_t = decltype(&PlayerCharacter::QueueFastTravel);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::QueueFastTravel };
+			return func(this, a_marker, a_allowAutoSave);
+		}
+
+		void RemoveLastUsedPowerArmor()
+		{
+			using func_t = decltype(&PlayerCharacter::RemoveLastUsedPowerArmor);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::RemoveLastUsedPowerArmor };
+			return func(this);
+		}
+
+		void SelectPerk(TESFormID a_formID, std::int8_t a_rank = 0)
+		{
+			using func_t = decltype(&PlayerCharacter::SelectPerk);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::SelectPerk };
+			return func(this, a_formID, a_rank);
+		}
+
+		void SetEscaping(bool a_flag, bool a_escaped)
+		{
+			using func_t = decltype(&PlayerCharacter::SetEscaping);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::SetEscaping };
+			return func(this, a_flag, a_escaped);
+		}
+
+		void SetVATSCriticalCount(uint32_t a_critCount)
+		{
+			using func_t = decltype(&PlayerCharacter::SetVATSCriticalCount);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::SetVATSCriticalCount };
+			return func(this, a_critCount);
+		}
+
+		void ShowPipboyLight(bool a_show, bool a_skipEffects)
+		{
+			using func_t = decltype(&PlayerCharacter::ShowPipboyLight);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::ShowPipboyLight };
+			return func(this, a_show, a_skipEffects);
+		}
+
+		void SetLastDialogueInput(uint32_t dialogueOption)
+		{
+			using func_t = decltype(&PlayerCharacter::SetLastDialogueInput);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::SetLastDialogueInput };
+			return func(this, dialogueOption);
+		}
+
+		void ClearPrison()
+		{
+			using func_t = decltype(&PlayerCharacter::ClearPrison);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::ClearPrison };
+			return func(this);
+		}
+
+		bool ReloadWeapon(const BGSObjectInstanceT<TESObjectWEAP>* a_weapon, BGSEquipIndex a_equipIndex)
+		{
+			using func_t = decltype(&PlayerCharacter::ReloadWeapon);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::ReloadWeapon };
+			return func(this, a_weapon, a_equipIndex);
+		}
+
+		void SetPerkCount(std::uint8_t a_count)
+		{
+			using func_t = decltype(&PlayerCharacter::SetPerkCount);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::SetPerkCount };
+			return func(this, a_count);
+		}
+
+		bool HasLOSToTarget(Actor* a_targetRef, bool* pickPerformed)
+		{
+			using func_t = decltype(&PlayerCharacter::HasLOSToTarget);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::HasLOSToTarget };
+			return func(this, a_targetRef, pickPerformed);
+		}
+
+		void SetAIControlledPackage(bool a_enable)
+		{
+			using func_t = decltype(&PlayerCharacter::SetAIControlledPackage);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::SetAIControlledPackage };
+			return func(this, a_enable);
+		}
+
+		void EnableRadio(bool a_enable)
+		{
+			using func_t = decltype(&PlayerCharacter::EnableRadio);
+			static REL::Relocation<func_t> func{ ID::PlayerCharacter::EnableRadio };
+			return func(this, a_enable);
+		}
+
+		// members
+		BSSpinLock                                                     actorToDisplayOnHUDLock;              // 628
+		BSSpinLock                                                     questTargetLock;                      // 630
+		BSTHashMap<const TESFaction*, CrimeGoldStruct>                 crimeGoldMap;                         // 638
+		BSTHashMap<const TESFaction*, StolenItemValueStruct>           stolenItemValueMap;                   // 668
+		PlayerCoverData                                                coverData;                            // 698
+		ObjectRefHandle                                                commandWaitMarker;                    // 6C4
+		BSTHashMap<const TESFaction*, FriendshipFactionsStruct>        factionOwnerFriendsMap;               // 6C8
+		NiPoint3A                                                      lastKnownGoodPosition;                // 700
+		NiPoint3A                                                      lastKnownGoodNavmeshPosition;         // 710
+		NiPoint3                                                       bulletAutoAim;                        // 720
+		NiPoint3                                                       cachedVelocity;                       // 72C
+		BSTArray<ObjectRefHandle>                                      currentMapMarkers;                    // 738
+		BSTArray<BSTTuple<NiPoint3, AITimeStamp>>                      velocityArray;                        // 750
+		BSTArray<ProjectileHandle>                                     runesCast;                            // 768
+		BSTArray<TESImageSpaceModifier*>                               animationImageSpaceModifiers;         // 78-
+		BSTArray<ImageSpaceModifierInstanceForm*>                      animationImageSpaceInstances;         // 798
+		BSTArray<BSTTuple<NiPointer<NiLight>, bool>>                   playerLights;                         // 7B0
+		BSSimpleList<TESQuestStageItem*>                               questLog;                             // 7C8
+		BSTArray<BGSInstancedQuestObjective>                           objectives;                           // 7D9
+		BSTHashMap<TESQuest*, QuestTargetArray*>                       questTargets;                         // 7F0
+		BSTHashMap<std::uint32_t, SayOnceTimeStampStruct>              currentSayOnceInfosMap;               // 820
+		BSTHashMap<std::uint32_t, SayOnceTimeStampStruct>              currentSpeechRepeatMap;               // 850
+		BSSimpleList<ObjectRefHandle>                                  droppedRefList;                       // 880
+		NiTMap<std::uint32_t, std::uint8_t>                            randomDoorSpaceMap;                   // 890
+		TESWorldSpace*                                                 cachedWorldspace;                     // 8B0
+		NiPoint3                                                       exteriorPosition;                     // 8B8
+		BSTSmallArray<SubgraphHandle, 2>                               pipboyAnimSubGraph;                   // 8C8
+		PLAYER_TARGET_LOC                                              queuedTargetLoc;                      // 8E8
+		PLAYER_TARGET_LOC                                              queuedFlightLoc;                      // 948
+		NiPoint3A                                                      flightGridCenter;                     // 9B0
+		BSPathingSolution*                                             flightMountPathingSolution;           // 9C0
+		const TESObjectCELL*                                           flightMountPreloadCell;               // 9C8
+		BSSoundHandle                                                  magicFailureSound;                    // 9D0
+		BSTArray<std::uint32_t>                                        rumorTopicInfoList;                   // 9D8
+		std::uint32_t                                                  testChallangeInfoID;                  // 9F0
+		DialoguePackage*                                               closestConversation;                  // 9F8
+		DialoguePackage*                                               aiConversationRunning;                // A00
+		std::int32_t                                                   numberofStealWarnings;                // A08
+		float                                                          stealWarningTimer;                    // A0C
+		std::int32_t                                                   numberofPickpocketWarnings;           // A10
+		float                                                          pickPocketWarningTimer;               // A14
+		AITimeStamp                                                    warnToLeaveTimeStamp;                 // A18
+		AITimeStamp                                                    usingTeleportDoorTimeStamp;           // A1C
+		NiPointer<ImageSpaceModifierInstanceDOF>                       ironsightsDOFInstance;                // A20
+		TESFaction*                                                    currentPrisonFaction;                 // A28
+		std::uint32_t                                                  jailSentence;                         // A30
+		NiPointer<NiAVObject>                                          autoAimDebugSphere;                   // A38
+		BGSNote*                                                       currHolotape;                         // A40
+		BSSoundHandle                                                  soundHand;                            // A48
+		std::int32_t                                                   vampireFeedDetection;                 // A50
+		std::uint32_t                                                  mapMarkerIterator;                    // A54
+		ObjectRefHandle                                                forceActivateRef;                     // A58
+		ObjectRefHandle                                                loopingActivateRef;                   // A5C
+		std::uint32_t                                                  dialogueCameraLastSceneID;            // A60
+		PlayerActionObject                                             playerActionObjects[15];              // A64
+		REX::TEnumSet<PLAYER_ACTION, std::int32_t>                     mostRecentAction;                     // B18
+		ActorHandle                                                    actorDoingPlayerCommand;              // B1C
+		BSTValueEventSource<PlayerCommandTypeEvent>                    playerCurrentCommandType;             // B20
+		BSTArray<void*>                                                grabSprings;                          // B38 - hkRefPtr<hknpBSMouseSpringAction>
+		NiPoint3                                                       grabUserRotation;                     // B50
+		ObjectRefHandle                                                grabbedObject;                        // B5C
+		float                                                          grabObjectWeight;                     // B60
+		float                                                          grabDistance;                         // B64
+		std::uint32_t                                                  secondsToSleepPerUpdate;              // B68
+		std::uint32_t                                                  sleepSeconds;                         // B6C
+		BSTSmartPointer<BipedAnim>                                     firstPersonBipedAnim;                 // B70
+		NiPointer<NiNode>                                              firstPerson3D;                        // B78
+		NiAVObject*                                                    firstPersonTorso;                     // B80
+		NiAVObject*                                                    firstPersonEye;                       // B88
+		float                                                          eyeHeight;                            // B90
+		float                                                          greetTimer;                           // B94
+		float                                                          encumberedTimer;                      // B98
+		float                                                          powerAttackTimer;                     // B9C
+		float                                                          autoReloadTimer;                      // BA0
+		float                                                          pivotToFaceCamera;                    // BA4
+		std::int32_t                                                   hourstosleep;                         // BA8
+		std::int32_t                                                   amountStolenSold;                     // BAC
+		std::uint32_t                                                  valueStolen;                          // BB0
+		ActorHandle                                                    lastRiddenMount;                      // BB4
+		ActorHandle                                                    lightTarget;                          // BB8
+		float                                                          sortActorDistanceTimer;               // BBC
+		float                                                          sitHeadingDelta;                      // BC0
+		ObjectRefHandle                                                playerMapMarker;                      // BC4
+		TeleportPath*                                                  playerMarkerPath;                     // BC8
+		std::uint32_t                                                  skillTrainingsThisLevel;              // BD0
+		TESClass*                                                      defaultClass;                         // BD8
+		std::uint32_t                                                  crimeCounts[7];                       // BE0
+		AlchemyItem*                                                   pendingPoison;                        // C00
+		std::time_t                                                    lastPlayingTimeUpdate;                // C08
+		std::time_t                                                    totalPlayingTime;                     // C10
+		std::uint32_t                                                  characterSeed;                        // C18
+		TESForm*                                                       lastKnownGoodLocation;                // C20
+		NiPointer<BSLight>                                             firstPersonLight;                     // C28
+		NiPointer<BSLight>                                             thirdPersonLight;                     // C30
+		NiPointer<BSLight>                                             pipboyLight;                          // C38
+		NiPointer<NiLight>                                             niPipboyLight;                        // C40
+		float                                                          dropAngleMod;                         // C48
+		float                                                          lastDropAngleMod;                     // C4C
+		BSTValueEventSource<PlayerAutoAimActorEvent>                   autoAimActor;                         // C50
+		ObjectRefHandle                                                homingTarget;                         // C68
+		float                                                          homingTargetTimer;                    // C6C
+		NiPointer<NiAVObject>                                          targeted3D;                           // C70
+		CombatGroup*                                                   combatGroup;                          // C78
+		BSTArray<ActorHandle>                                          actorsToDisplayOnTheHUD;              // C80
+		BSTArray<EquippedItem>                                         lastOneHandItems;                     // C98
+		std::uint32_t                                                  teammateCount;                        // CB0
+		float                                                          combatTimer;                          // CB4
+		float                                                          yieldTimer;                           // CB8
+		float                                                          chaseTimer;                           // CBC
+		float                                                          drawSheatheSafetyTimer;               // CC0
+		std::uint32_t                                                  activeCombatantCount;                 // CC4
+		BGSLocation*                                                   currentLocation;                      // CC8
+		AITimeStamp                                                    cachedVelocityTimeStamp;              // CD0
+		float                                                          telekinesisDistance;                  // CD4
+		float                                                          commandTimer;                         // CD8
+		float                                                          dialogueCameraChangeRate;             // CDC
+		float                                                          fireWeaponEventTimer;                 // CE0
+		REX::TEnumSet<DEFAULT_OBJECT, std::int32_t>                    animationObjectAction;                // CE4
+		REX::TEnumSet<GrabbingType, std::int32_t>                      grabType;                             // CE8
+		ActorHandle                                                    assumedIdentity;                      // CEC
+		std::int8_t                                                    murder;                               // CF0
+		std::int8_t                                                    perkCount;                            // CF1
+		std::int8_t                                                    byCharGenFlag;                        // CF2
+		Crime*                                                         resistArrestCrime;                    // CF8
+		BGSCharacterTint::Entries*                                     tintingData;                          // D00
+		BGSTextureSet*                                                 complexion;                           // D08
+		TESRace*                                                       charGenRace;                          // D10
+		EffectSetting*                                                 currentAlchemyEffect;                 // D18
+		ItemChange*                                                    currentTemperingInventoryItem;        // D20
+		TESObjectREFR*                                                 commandTarget;                        // D28
+		TESObjectREFR*                                                 walkThroughDoor;                      // D30
+		REX::TEnumSet<COMMAND_TYPE, std::int32_t>                      currentCommand;                       // D38
+		REX::TEnumSet<SCENE_ACTION_PLAYER_RESPONSE_TYPE, std::int32_t> playerDialogueInput;                  // D3C
+		ActorValueInfo*                                                stimpakTarget;                        // D40
+		float                                                          vatsCriticalCharge;                   // D48
+		std::uint32_t                                                  vatsCriticalCount;                    // D4C
+		std::uint32_t                                                  maxVATSCriticalCount;                 // D50
+		float                                                          timeBlendingOutFirstPersonOffset;     // D54
+		ActorHandle                                                    lastMagnetismActor;                   // D58
+		NiPoint3                                                       magnetismActorPos;                    // D5C
+		ObjectRefHandle                                                workstationBeingLeft;                 // D68
+		ActorHandle                                                    actorLeavingWorkstation;              // D6C
+		BGSScene*                                                      allowDialogueCameraScene;             // D70
+		ActorHandle                                                    helloActor;                           // D78
+		TESObjectREFR*                                                 weaponAmmoRef;                        // D80
+		std::int32_t                                                   equippingAmmoCount;                   // D88
+		float                                                          dialogueCameraResumeTimer;            // D8C
+		ObjectRefHandle                                                lastUsedPowerArmor;                   // D90
+		TeleportPath*                                                  lastUsedPowerArmorMarkerPath;         // D98
+		TESObjectWEAP*                                                 lastUsedThrownWeapon;                 // DA0
+		BSSoundHandle                                                  powerArmorInteriorSoundHandle;        // DA8
+		BSTArray<BSTTuple<ObjectRefHandle, float>>                     lockedTerminals;                      // DB0
+		BSTArray<BSTTuple<std::int32_t, std::int32_t>>                 boneMapping1stTo3rd;                  // DC8
+		BSTOptional<XPChangeData>                                      syncedXPChange;                       // DE0
+		std::int32_t                                                   queuedSwitch: 1;                      // DF4:00
+		std::uint32_t                                                  charGenHUDMode;                       // DF8
+		bool                                                           insideMemoryHUDMode: 1;               // DFC:0
+		bool                                                           xpSyncedWithHUDNotification: 1;       // DFC:1
+		bool                                                           travelUseDoor: 1;                     // DFC:2
+		bool                                                           transporting: 1;                      // DFC:3
+		bool                                                           overAutoAimTarget: 1;                 // DFC:4
+		bool                                                           showQuestItemsInInventory: 1;         // DFC:5
+		bool                                                           hostileDetection: 1;                  // DFC:6
+		bool                                                           escaping: 1;                          // DFC:7
+		bool                                                           forceQuestTargetRepath: 1;            // DFD:0
+		bool                                                           speaking: 1;                          // DFD:1
+		bool                                                           isSleeping: 1;                        // DFD:2
+		bool                                                           actorinSneakRange: 1;                 // DFD:3
+		bool                                                           greetingPlayer: 1;                    // DFD:4
+		bool                                                           beenAttacked: 1;                      // DFD:5
+		bool                                                           allowEGMCacheClear: 1;                // DFD:6
+		bool                                                           aiControlledToPos: 1;                 // DFD:7
+		bool                                                           aiControlledFromPos: 1;               // DFE:0
+		bool                                                           aiControlledPackage: 1;               // DFE:1
+		bool                                                           returnToLastKnownGoodPosition: 1;     // DFE:2
+		bool                                                           beingChased: 1;                       // DFE:3
+		bool                                                           is3rdPersonModelShown: 1;             // DFE:4
+		bool                                                           hideFirstPersonGeometry: 1;           // DFE:5
+		bool                                                           insufficientChargeMessageShownL: 1;   // DFE:6
+		bool                                                           insufficientChargeMessageShownR: 1;   // DFE:7
+		bool                                                           target3DDistant: 1;                   // DFF:0
+		bool                                                           playerInCombat: 1;                    // DFF:1
+		bool                                                           attemptedYieldInCurrentCombat: 1;     // DFF:2
+		bool                                                           currentAlchemyIsPoison: 1;            // DFF:3
+		bool                                                           positioning: 1;                       // DFF:4
+		bool                                                           crimeReporting: 1;                    // DFF:5
+		bool                                                           healthTutorialShown: 1;               // DFF:6
+		bool                                                           magickaTutorialShown: 1;              // DFF:7
+		bool                                                           staminaTutorialShown: 1;              // E00:0
+		bool                                                           goToJailQueued: 1;                    // E00:1
+		bool                                                           doorAutosaveQueued: 1;                // E00:2
+		bool                                                           sprintToggled: 1;                     // E00:3
+		bool                                                           useHighSpeedLoading: 1;               // E00:4
+		bool                                                           sceneActionActive: 1;                 // E00:5
+		bool                                                           sayingHello: 1;                       // E00:6
+		bool                                                           disabledRadio: 1;                     // E00:7
+		bool                                                           updateAutoAimActor: 1;                // E01:0
+		bool                                                           autoReload: 1;                        // E01:1
+		bool                                                           usingScopeWithOverlay: 1;             // E01:2
+		bool                                                           steadyingWeapon: 1;                   // E01:3
+		bool                                                           speechChallengeReward: 1;             // E01:4
+		bool                                                           blendOutFirstPersonOffset: 1;         // E01:5
+		bool                                                           dialogueCameraConsiderResume: 1;      // E01:6
+		bool                                                           shouldFollowerSupressIdleChatter: 1;  // E01:7
+		bool                                                           idleChatter: 1;                       // E02:0
+		bool                                                           switchingPerspectives: 1;             // E02:1
+		bool                                                           onElevator: 1;                        // E02:2
+		bool                                                           sayCommandResponse: 1;                // E02:3
+		bool                                                           inLooksMenu: 1;                       // E02:4
+		bool                                                           playingTimeFrozen: 1;                 // E02:5
+		bool                                                           everModded: 1;                        // E02:6
+	};
+	static_assert(sizeof(PlayerCharacter) == 0xE10);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerCharacterQuestEvent.h

@@ -0,0 +1,27 @@
+#pragma once
+
+namespace RE
+{
+	class BGSInstancedQuestObjective;
+
+	namespace PlayerCharacterQuestEvent
+	{
+		enum Type : std::int32_t
+		{
+			kAddObjective = 0x0,
+			kUpdateObjective = 0x1,
+			kRemoveQuest = 0x2,
+			kRemoveQuestTarget = 0x3,
+			kUpdateQuestTarget = 0x4
+		};
+
+		class Event
+		{
+		public:
+			// members
+			PlayerCharacterQuestEvent::Type changeType;      // 00
+			BGSInstancedQuestObjective*     questObjective;  // 08
+		};
+		static_assert(sizeof(Event) == 0x10);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PlayerCommandTypeEvent.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	enum class COMMAND_TYPE;
+
+	class PlayerCommandTypeEvent :
+		public BSTValueEvent<COMMAND_TYPE>  // 0
+	{
+	public:
+	};
+	static_assert(sizeof(PlayerCommandTypeEvent) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerControls.h

@@ -0,0 +1,110 @@
+#pragma once
+
+#include "RE/A/ActionInput.h"
+#include "RE/B/BSInputEventReceiver.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTSingleton.h"
+#include "RE/H/HeldStateHandler.h"
+#include "RE/I/IMovementPlayerControls.h"
+#include "RE/P/PlayerInputHandler.h"
+
+namespace RE
+{
+	enum class DEFAULT_OBJECT;
+	class ActivateHandler;
+	class AttackBlockHandler;
+	class AutoMoveHandler;
+	class GrabRotationHandler;
+	class JumpHandler;
+	class LookHandler;
+	class MeleeThrowHandler;
+	class MenuModeChangeEvent;
+	class MenuOpenCloseEvent;
+	class MovementHandler;
+	class QuickContainerStateEvent;
+	class ReadyWeaponHandler;
+	class RunHandler;
+	class SneakHandler;
+	class SprintHandler;
+	class TogglePOVHandler;
+	class ToggleRunHandler;
+	class UserEventEnabledEvent;
+	class TESFurnitureEvent;
+
+	class __declspec(novtable) PlayerControls :
+		public BSInputEventReceiver,                    // 000
+		public BSTEventSink<MenuOpenCloseEvent>,        // 010
+		public BSTEventSink<MenuModeChangeEvent>,       // 018
+		public BSTEventSink<TESFurnitureEvent>,         // 020
+		public BSTEventSink<UserEventEnabledEvent>,     // 028
+		public IMovementPlayerControls,                 // 030
+		public BSTEventSink<QuickContainerStateEvent>,  // 038
+		public BSTSingletonSDM<PlayerControls>          // 040
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PlayerControls };
+		static constexpr auto VTABLE{ VTABLE::PlayerControls };
+
+		enum class LERP_GRAPH
+		{
+			kMovementThird = 0x0,
+			kMovementFirst = 0x1,
+			kLooking = 0x2
+		};
+
+		static PlayerControls* GetSingleton()
+		{
+			static REL::Relocation<PlayerControls**> singleton{ ID::PlayerControls::Singleton };
+			return *singleton;
+		}
+
+		bool DoAction(DEFAULT_OBJECT a_action, ActionInput::ACTIONPRIORITY a_priority)
+		{
+			using func_t = decltype(&PlayerControls::DoAction);
+			static REL::Relocation<func_t> func{ ID::PlayerControls::DoAction };
+			return func(this, a_action, a_priority);
+		}
+
+		void RegisterHandler(PlayerInputHandler* a_handler) { DoRegisterHandler(a_handler, false); }
+		void RegisterHandler(HeldStateHandler* a_handler) { DoRegisterHandler(a_handler, true); }
+
+		// members
+		PlayerControlsData            data;                    // 044
+		BSTArray<PlayerInputHandler*> handlers;                // 090
+		BSTArray<HeldStateHandler*>   heldStateHandlers;       // 0A8
+		std::uint32_t                 topGraphPoint[3];        // 0C0
+		float                         graphPoints[3][10][2];   // 0CC
+		BSTArray<ActorHandle>         actionInterestedActors;  // 1C0
+		BSSpinLock                    actorArraySpinLock;      // 1D8
+		MovementHandler*              movementHandler;         // 1E0
+		LookHandler*                  lookHandler;             // 1E8
+		SprintHandler*                sprintHandler;           // 1F0
+		ReadyWeaponHandler*           readyWeaponHandler;      // 1F8
+		AutoMoveHandler*              autoMoveHandler;         // 200
+		ToggleRunHandler*             toggleRunHandler;        // 208
+		ActivateHandler*              activateHandler;         // 210
+		JumpHandler*                  jumpHandler;             // 218
+		AttackBlockHandler*           attackHandler;           // 220
+		RunHandler*                   runHandler;              // 228
+		SneakHandler*                 sneakHandler;            // 230
+		TogglePOVHandler*             togglePOVHandler;        // 238
+		MeleeThrowHandler*            meleeThrowHandler;       // 240
+		GrabRotationHandler*          grabRotationHandler;     // 248
+		bool                          notifyingHandlers;       // 250
+		bool                          blockPlayerInput;        // 251
+		float                         cameraAutoRotationX;     // 254
+		float                         cameraAutoRotationY;     // 258
+
+	private:
+		void DoRegisterHandler(PlayerInputHandler* a_handler, bool a_isHeldStateHandler)
+		{
+			using func_t = decltype(&PlayerControls::DoRegisterHandler);
+			static REL::Relocation<func_t> func{ ID::PlayerControls::DoRegisterHandler };
+			return func(this, a_handler, a_isHeldStateHandler);
+		}
+	};
+	static_assert(sizeof(PlayerControls) == 0x260);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerControlsData.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSSpring_SpringState.h"
+#include "RE/N/NiPoint2.h"
+
+namespace RE
+{
+	class PlayerControlsData
+	{
+	public:
+		// members
+		NiPoint2                        moveInputVec;               // 00
+		NiPoint2                        lookInputVec;               // 08
+		NiPoint2                        lookInputVecNormalized;     // 10
+		NiPoint2                        prevMoveVec;                // 18
+		NiPoint2                        prevLookVec;                // 20
+		BSSpring::SpringState<NiPoint3> rotationSpeedSpring;        // 28
+		bool                            autoMove;                   // 44
+		bool                            running;                    // 45
+		bool                            togglePOV;                  // 46
+		bool                            vanityModeEnabled;          // 47
+		bool                            checkHeldStates;            // 48
+		bool                            setupHeldStatesForRelease;  // 49
+	};
+	static_assert(sizeof(PlayerControlsData) == 0x4C);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerControlsMovementData.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/M/MovementData.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class PlayerControlsMovementData :
+		public MovementData  // 00
+	{
+	public:
+		// members
+		NiPoint3A targetAngle;  // 30
+	};
+	static_assert(sizeof(PlayerControlsMovementData) == 0x40);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerCoverData.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class PlayerCoverData
+	{
+	public:
+		enum class PEEK_STATE : std::int32_t;
+
+		// members
+		NiPoint3   coverLocation;  // 00
+		NiPoint3   peekLocation;   // 0C
+		float      peekTimer;      // 18
+		float      updateTimer;    // 2C
+		float      blockedTimer;   // 20
+		PEEK_STATE peekState;      // 24
+		bool       gunBlocked;     // 28
+	};
+	static_assert(sizeof(PlayerCoverData) == 0x2C);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerCrosshairModeEvent.h

@@ -0,0 +1,24 @@
+#pragma once
+
+namespace RE
+{
+	enum class CrosshairMode;
+
+	class PlayerCrosshairModeEvent :
+		public BSTValueEvent<CrosshairMode>
+	{
+	private:
+		using EventSource_t = BSTGlobalEvent::EventSource<PlayerCrosshairModeEvent>;
+
+	public:
+		[[nodiscard]] static EventSource_t* GetEventSource()
+		{
+			static REL::Relocation<EventSource_t**> singleton{ ID::PlayerCrosshairModeEvent::GetEventSource };
+			if (!*singleton) {
+				*singleton = new EventSource_t(&BSTGlobalEvent::GetSingleton()->eventSourceSDMKiller);
+			}
+			return *singleton;
+		}
+	};
+	static_assert(sizeof(PlayerCrosshairModeEvent) == 0x08);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerDifficultySettingChanged.h

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	namespace PlayerDifficultySettingChanged
+	{
+		class Event
+		{
+		public:
+			// members
+			std::uint32_t oldDifficulty;  // 00
+			std::uint32_t newDifficulty;  // 04
+		};
+		static_assert(sizeof(Event) == 0x8);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PlayerInDialogueChanged.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	namespace PlayerInDialogueChanged
+	{
+		class Event
+		{
+		public:
+			// members
+			bool isPlayerInDialogue;  // 00
+		};
+		static_assert(sizeof(Event) == 0x1);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PlayerInputHandler.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/B/BSInputEventUser.h"
+#include "RE/P/PlayerControlsData.h"
+
+namespace RE
+{
+	class PlayerInputHandler :
+		public BSInputEventUser  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PlayerInputHandler };
+		static constexpr auto VTABLE{ VTABLE::PlayerInputHandler };
+
+		explicit constexpr PlayerInputHandler(PlayerControlsData& a_data) noexcept :
+			data(a_data)
+		{}
+
+		// NOLINTNEXTLINE(modernize-use-override)
+		virtual ~PlayerInputHandler() = default;  // 00
+
+		// add
+		virtual void PerFrameUpdate() { return; };  // 09
+
+		// members
+		PlayerControlsData& data;                       // 10
+		bool                inQuickContainer{ false };  // 18
+	};
+	static_assert(sizeof(PlayerInputHandler) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerLifeStateChanged.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace RE
+{
+	enum class ACTOR_LIFE_STATE;
+
+	namespace PlayerLifeStateChanged
+	{
+		class Event
+		{
+		public:
+			// members
+			ACTOR_LIFE_STATE lifeState;  // 00
+		};
+		static_assert(sizeof(Event) == 0x4);
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PlayerUpdateEvent.h

@@ -0,0 +1,10 @@
+#pragma once
+
+namespace RE
+{
+	class PlayerUpdateEvent
+	{
+	public:
+	};
+	static_assert(std::is_empty_v<PlayerUpdateEvent>);
+}

plugin/lib/commonlibf4/include/RE/P/PlayerWeaponReloadEvent.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class PlayerWeaponReloadEvent :
+		public BSTValueEvent<bool>
+	{
+	public:
+	};
+	static_assert(sizeof(PlayerWeaponReloadEvent) == 0x2);
+}

plugin/lib/commonlibf4/include/RE/P/PositionPlayerEvent.h

@@ -0,0 +1,22 @@
+#pragma once
+
+namespace RE
+{
+	class PositionPlayerEvent
+	{
+	public:
+		enum EVENT_TYPE : std::int32_t
+		{
+			kPrePositionPlayer = 0x0,
+			kPositionPlayerPreUpdatePackages = 0x1,
+			kPositionPlayerPostUpdatePackages = 0x2,
+			kPostPositionPlayer = 0x3,
+			kFinishPositionPlayer = 0x4,
+		};
+
+		// members
+		EVENT_TYPE type;          // 00
+		bool       NoLoadScreen;  // 04
+	};
+	static_assert(sizeof(PositionPlayerEvent) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/P/PowerArmor.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include "RE/P/PlayerCharacter.h"
+#include "RE/S/Setting.h"
+
+namespace RE
+{
+	class BGSInventoryItem;
+
+	namespace PowerArmor
+	{
+		[[nodiscard]] inline bool ActorInPowerArmor(const Actor& a_actor)
+		{
+			using func_t = decltype(&ActorInPowerArmor);
+			static REL::Relocation<func_t> func{ ID::PowerArmor::ActorInPowerArmor };
+			return func(a_actor);
+		}
+
+		[[nodiscard]] inline bool PlayerInPowerArmor()
+		{
+			auto PlayerCharacter = PlayerCharacter::GetSingleton();
+			return PlayerCharacter ? ActorInPowerArmor(*PlayerCharacter) : false;
+		}
+
+		[[nodiscard]] inline BGSKeyword* GetArmorKeyword()
+		{
+			using func_t = decltype(&GetArmorKeyword);
+			static REL::Relocation<func_t> func{ ID::PowerArmor::GetArmorKeyword };
+			return func();
+		}
+
+		[[nodiscard]] inline BGSKeyword* GetBatteryKeyword()
+		{
+			using func_t = decltype(&GetBatteryKeyword);
+			static REL::Relocation<func_t> func{ ID::PowerArmor::GetBatteryKeyword };
+			return func();
+		}
+
+		[[nodiscard]] inline TESAmmo* GetDefaultBatteryObject()
+		{
+			using func_t = decltype(&GetDefaultBatteryObject);
+			static REL::Relocation<func_t> func{ ID::PowerArmor::GetDefaultBatteryObject };
+			return func();
+		}
+
+		[[nodiscard]] inline bool IsPowerArmorBattery(const TESBoundObject* a_itemData)
+		{
+			using func_t = decltype(&IsPowerArmorBattery);
+			static REL::Relocation<func_t> func{ ID::PowerArmor::IsPowerArmorBattery };
+			return func(a_itemData);
+		}
+
+		inline void SyncFurnitureVisualsToInventory(TESObjectREFR* a_furniture, bool a_force3DUpdate, BGSInventoryItem* a_tempItemToAdd, bool a_hideCore)
+		{
+			using func_t = decltype(&SyncFurnitureVisualsToInventory);
+			static REL::Relocation<func_t> func{ ID::PowerArmor::SyncFurnitureVisualsToInventory };
+			return func(a_furniture, a_force3DUpdate, a_tempItemToAdd, a_hideCore);
+		}
+
+		[[nodiscard]] inline SettingT<GameSettingCollection>* GetNewBatteryCapacity()
+		{
+			static REL::Relocation<SettingT<GameSettingCollection>*> value{ ID::PowerArmor::fNewBatteryCapacity };
+			return value.get();
+		}
+	}
+}

plugin/lib/commonlibf4/include/RE/P/PowerArmorGeometry.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTSingleton.h"
+#include "RE/C/CurrentRadiationSourceCount.h"
+#include "RE/C/CurrentRadsDisplayMagnitude.h"
+#include "RE/C/CurrentRadsPercentOfLethal.h"
+#include "RE/H/HUDModes.h"
+#include "RE/N/NiPointer.h"
+#include "RE/P/PipboyLightEvent.h"
+#include "RE/P/PlayerAmmoCountEvent.h"
+#include "RE/P/PlayerWeaponReloadEvent.h"
+#include "RE/S/SimpleAnimationGraphManagerHolder.h"
+
+namespace RE
+{
+	class NiAVObject;
+	class NiNode;
+
+	namespace ExitPowerArmor
+	{
+		class Event;
+	}
+
+	namespace PreloadPowerArmor
+	{
+		class Event;
+	}
+
+	class __declspec(novtable) PowerArmorGeometry :
+		public SimpleAnimationGraphManagerHolder,       // 00
+		public BSTEventSink<PreloadPowerArmor::Event>,  // 18
+		public BSTEventSink<ExitPowerArmor::Event>,     // 20
+		public BSIntrusiveRefCounted,                   // 28
+		public BSTSingletonSDM<PowerArmorGeometry>      // 2C
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PowerArmorGeometry };
+		static constexpr auto VTABLE{ VTABLE::PowerArmorGeometry };
+
+		virtual ~PowerArmorGeometry();  // 00
+
+		// override
+		virtual void                 BackgroundTaskFinishedLoading() override;                                                                            // 01
+		virtual BSEventNotifyControl ProcessEvent(const PreloadPowerArmor::Event& a_event, BSTEventSource<PreloadPowerArmor::Event>* a_source) override;  // 02
+		virtual BSEventNotifyControl ProcessEvent(const ExitPowerArmor::Event& a_event, BSTEventSource<ExitPowerArmor::Event>* a_source) override;        // 03
+
+		[[nodiscard]] static PowerArmorGeometry* GetSingleton()
+		{
+			static REL::Relocation<PowerArmorGeometry**> singleton{ ID::PowerArmorGeometry::Singleton };
+			return *singleton;
+		}
+
+		void HidePipboyPAGeometry()
+		{
+			using func_t = decltype(&PowerArmorGeometry::HidePipboyPAGeometry);
+			static REL::Relocation<func_t> func{ ID::PowerArmorGeometry::HidePipboyPAGeometry };
+			return func(this);
+		}
+
+		void ShowPipboyPAGeometry()
+		{
+			using func_t = decltype(&PowerArmorGeometry::ShowPipboyPAGeometry);
+			static REL::Relocation<func_t> func{ ID::PowerArmorGeometry::ShowPipboyPAGeometry };
+			return func(this);
+		}
+
+		// members
+		BSTValueEventSink<PipboyLightEvent>            pipboySpotLightEvent;        // 030
+		BSTValueEventSink<PlayerAmmoCountEvent>        nextAmmoCount;               // 048
+		BSTValueEventSink<PlayerWeaponReloadEvent>     playerReloaded;              // 068
+		BSTValueEventSink<CurrentRadsDisplayMagnitude> radsCount;                   // 080
+		BSTValueEventSink<CurrentRadsPercentOfLethal>  radsPercentOfLethal;         // 0A0
+		BSTValueEventSink<CurrentRadiationSourceCount> radiationSourceCount;        // 0C0
+		TESImageSpaceModifier*                         paPipboyEffect;              // 0E0
+		NiPointer<NiNode>                              paDashDials;                 // 0E8
+		NiPointer<NiNode>                              pipboyPAGlass;               // 0F0
+		NiAVObject*                                    paDashLightSpot;             // 0F8
+		NiAVObject*                                    paDashLightScope;            // 100
+		NiAVObject*                                    paDashLightAux;              // 108
+		NiAVObject*                                    paDash;                      // 110
+		NiAVObject*                                    plane;                       // 118
+		NiAVObject*                                    compass;                     // 120
+		BSTArray<void*>                                queued3D;                    // 128
+		HUDModes                                       validHUDModes;               // 140
+		float                                          radiationSmoother;           // 160
+		NiPointer<NiNode>                              dbHUDRain;                   // 168
+		bool                                           hudRain;                     // 170
+		bool                                           prevShouldBeVisible;         // 171
+		bool                                           powerArmorEmergencyLightOn;  // 172
+		bool                                           queueInit;                   // 173
+		bool                                           prevIsFirstPerson;           // 174
+		bool                                           ammoDirty;                   // 175
+		bool                                           initialized;                 // 176
+	};
+	static_assert(sizeof(PowerArmorGeometry) == 0x178);
+}

plugin/lib/commonlibf4/include/RE/P/PowerArmorLightData.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class PowerArmorLightData
+	{
+	private:
+		using EventSource_t = BSTGlobalEvent::EventSource<PowerArmorLightData>;
+
+	public:
+		[[nodiscard]] static EventSource_t* GetEventSource()
+		{
+			static REL::Relocation<EventSource_t**> singleton{ ID::PowerArmorLightData::GetEventSource };
+			if (!*singleton) {
+				*singleton = new EventSource_t(&BSTGlobalEvent::GetSingleton()->eventSourceSDMKiller);
+			}
+			return *singleton;
+		}
+
+		// members
+		bool lightOn;  // 00
+	};
+	static_assert(sizeof(PowerArmorLightData) == 0x1);
+}

plugin/lib/commonlibf4/include/RE/P/PowerArmorModMenu.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "RE/E/ExamineMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) PowerArmorModMenu :
+		public ExamineMenu
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PowerArmorModMenu };
+		static constexpr auto VTABLE{ VTABLE::PowerArmorModMenu };
+		static constexpr auto MENU_NAME{ "PowerArmorModMenu"sv };
+
+		virtual ~PowerArmorModMenu();  // 00
+
+		// override (ExamineMenu)
+		virtual void                 PreDisplay() override;
+		virtual void                 BuildCanceled() override;                                                                                                                    // 16
+		virtual void                 BuildConfirmed(bool a_ownerIsWorkbench) override;                                                                                            // 17
+		virtual bool                 GetWorkbenchHasInventory() override;                                                                                                         // 18
+		virtual const ModChoiceData* QCurrentModChoiceData() override;                                                                                                            // 19
+		virtual void                 ShowBuildFailureMessage() override;                                                                                                          // 1A
+		virtual EQUIP_TYPE           GetInventoryEntryEquipState(const InventoryUserUIInterfaceEntry& a_entry) override;                                                          // 1C
+		virtual void                 ShowCurrent3D() override;                                                                                                                    // 1D
+		virtual void                 HighlightWeaponPart() override;                                                                                                              // 28
+		virtual void                 ResetHighlight() override;                                                                                                                   // 29
+		virtual void                 CreateModdedInventoryItem() override;                                                                                                        // 2A
+		virtual const char*          GetBuildConfirmButtonLabel() override;                                                                                                       // 30
+		virtual void                 GetBuildConfirmQuestion(char* a_buffer, std::uint32_t a_bufferLength) override;                                                              // 31
+		virtual bool                 GetCanRepairSelectedItem() override;                                                                                                         // 32
+		virtual NiAVObject*          GetCurrent3D() override;                                                                                                                     // 33
+		virtual bool                 GetCurrent3DLoaded() override;                                                                                                               // 34
+		virtual bool                 GetIsValidInventoryItem(const BGSInventoryItem& a_item, std::uint32_t a_stackID) override;                                                   // 35
+		virtual const char*          GetMenuName() override;                                                                                                                      // 36
+		virtual void                 OnSwitchBaseItem() override;                                                                                                                 // 37
+		virtual void                 PopulateInventoryItemObj(ObjectRefHandle a_owner, const InventoryUserUIInterfaceEntry& a_entry, Scaleform::GFx::Value& a_itemObj) override;  // 38
+		virtual void                 RegisterMenuComponents(const Scaleform::GFx::FunctionHandler::Params& a_params) override;                                                    // 39
+		virtual void                 RepairSelectedItem() override;                                                                                                               // 3A
+		virtual void                 SetFilter() override;                                                                                                                        // 3B
+		virtual void                 ToggleItemEquipped() override;                                                                                                               // 3D
+		virtual void                 UpdateModChoiceList() override;                                                                                                              // 3F
+
+		// members
+		WorkbenchMenuBase::ModChoiceData repairData;                  // 810
+		bool                             queuePreviewedPieceAttatch;  // 848
+	};
+	static_assert(sizeof(PowerArmorModMenu) == 0x850);
+}

plugin/lib/commonlibf4/include/RE/P/PowerUtils.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include "RE/B/BSCRC32.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTHashMap.h"
+
+namespace RE
+{
+	namespace PowerUtils
+	{
+		class GridConnection
+		{
+		public:
+			~GridConnection() noexcept {}  // NOLINT(modernize-use-equals-default)
+
+			// members
+			std::uint32_t connection{ 0 };  // 0 - the powered object
+			std::uint32_t connector{ 0 };   // 4 - how the object is connected
+		};
+		static_assert(sizeof(GridConnection) == 0x8);
+
+		class GridSaveLoadData
+		{
+		public:
+			// members
+			std::uint32_t  node{ 0 };   // 0
+			GridConnection connection;  // 4
+		};
+		static_assert(sizeof(GridSaveLoadData) == 0xC);
+
+		class PowerGrid
+		{
+		public:
+			// members
+			BSTHashMap<std::uint32_t, BSTSet<GridConnection>*> adjacencyMap;      // 00 - maps powered objects to the objects they connect to
+			BSTArray<GridSaveLoadData>                         loadGameData;      // 30
+			std::uint32_t                                      loadElement{ 0 };  // 48
+			BSTArray<std::uint32_t>                            currentlyPowered;  // 50
+			float                                              capacity{ 0.0 };   // 68
+			float                                              load{ 0.0 };       // 6C
+		};
+		static_assert(sizeof(PowerGrid) == 0x70);
+
+		class TraverseConnectionsOptions
+		{
+		public:
+			// members
+			std::uint32_t ignoreMode;  // 00
+			bool          wiredOnly;   // 04
+			bool          inputsOnly;  // 05
+		};
+		static_assert(sizeof(TraverseConnectionsOptions) == 0x8);
+
+		inline bool ItemIsPowerConnection(const TESObjectREFR* a_refr)
+		{
+			using func_t = decltype(&PowerUtils::ItemIsPowerConnection);
+			static REL::Relocation<func_t> func{ ID::PowerUtils::ItemIsPowerConnection };
+			return func(a_refr);
+		}
+
+		inline bool ItemIsPowerReceiver(const TESObjectREFR* a_refr)
+		{
+			using func_t = decltype(&PowerUtils::ItemIsPowerReceiver);
+			static REL::Relocation<func_t> func{ ID::PowerUtils::ItemIsPowerReceiver };
+			return func(a_refr);
+		}
+	}
+
+	template <>
+	struct BSCRC32<PowerUtils::GridConnection>
+	{
+	public:
+		[[nodiscard]] std::uint32_t operator()(const PowerUtils::GridConnection& a_connection) const noexcept
+		{
+			return detail::GenerateCRC32(
+				std::span(
+					reinterpret_cast<const std::uint8_t*>(std::addressof(a_connection)),
+					sizeof(PowerUtils::GridConnection)));
+		}
+	};
+}

plugin/lib/commonlibf4/include/RE/P/PrecomputedNavmeshInfoPathMap.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "RE/B/BSPrecomputedNavmeshInfoPathMap.h"
+
+namespace RE
+{
+	class PrecomputedNavmeshInfoPathMap :
+		public BSPrecomputedNavmeshInfoPathMap  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::PrecomputedNavmeshInfoPathMap };
+	};
+	static_assert(sizeof(PrecomputedNavmeshInfoPathMap) == 0x48);
+}

plugin/lib/commonlibf4/include/RE/P/ProcessLists.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include "RE/B/BSContainer.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSemaphore.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/B/BSTSingleton.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/B/BSTempEffect.h"
+#include "RE/M/ModelReferenceEffect.h"
+#include "RE/N/NiPointer.h"
+#include "RE/P/PTYPE.h"
+#include "RE/S/ShaderReferenceEffect.h"
+
+namespace RE
+{
+	class Crime;
+	class MuzzleFlash;
+	class PositionPlayerEvent;
+	class SyncQueueObj;
+
+	class __declspec(novtable) ProcessLists :
+		public BSTEventSink<PositionPlayerEvent>,  // 000
+		public BSTSingletonSDM<ProcessLists>       // 008
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ProcessLists };
+		static constexpr auto VTABLE{ VTABLE::ProcessLists };
+
+		virtual ~ProcessLists();  // 00
+
+		// override
+		virtual BSEventNotifyControl ProcessEvent(const PositionPlayerEvent&, BSTEventSource<PositionPlayerEvent>*) override;  // 01
+
+		[[nodiscard]] static ProcessLists* GetSingleton()
+		{
+			static REL::Relocation<ProcessLists**> singleton{ ID::ProcessLists::Singleton };
+			return *singleton;
+		}
+
+		[[nodiscard]] bool AreHostileActorsNear(BSScrapArray<ActorHandle>* a_hostileActorArray)
+		{
+			using func_t = decltype(&ProcessLists::AreHostileActorsNear);
+			static REL::Relocation<func_t> func{ ID::ProcessLists::AreHostileActorsNear };
+			return func(this, a_hostileActorArray);
+		}
+
+		void ForEachMagicTempEffect(std::function<BSContainer::ForEachResult(BSTempEffect*)> a_callback)
+		{
+			BSAutoLock locker(magicEffectsLock);
+
+			for (auto& tempEffectPtr : magicEffects) {
+				const auto& tempEffect = tempEffectPtr.get();
+				if (tempEffect && a_callback(tempEffect) == BSContainer::ForEachResult::kStop) {
+					break;
+				}
+			}
+		}
+
+		void ForEachModelEffect(std::function<BSContainer::ForEachResult(ModelReferenceEffect*)> a_callback)
+		{
+			ForEachMagicTempEffect([a_callback](BSTempEffect* a_tempEffect) {
+				const auto modelEffect = a_tempEffect->As<ModelReferenceEffect>();
+				if (modelEffect && a_callback(modelEffect) == BSContainer::ForEachResult::kStop) {
+					return BSContainer::ForEachResult::kStop;
+				}
+				return BSContainer::ForEachResult::kContinue;
+			});
+		}
+
+		void ForEachShaderEffect(std::function<BSContainer::ForEachResult(ShaderReferenceEffect*)> a_callback)
+		{
+			ForEachMagicTempEffect([a_callback](BSTempEffect* a_tempEffect) {
+				const auto shaderEffect = a_tempEffect->As<ShaderReferenceEffect>();
+				if (shaderEffect && a_callback(shaderEffect) == BSContainer::ForEachResult::kStop) {
+					return BSContainer::ForEachResult::kStop;
+				}
+				return BSContainer::ForEachResult::kContinue;
+			});
+		}
+
+		[[nodiscard]] bool IsActorTargetingREFinPackage(const TESObjectREFR* a_actor, PTYPE a_type, bool a_onlyHigh)
+		{
+			using func_t = decltype(&ProcessLists::IsActorTargetingREFinPackage);
+			static REL::Relocation<func_t> func{ ID::ProcessLists::IsActorTargetingREFinPackage };
+			return func(this, a_actor, a_type, a_onlyHigh);
+		}
+
+		[[nodiscard]] std::int16_t RequestHighestDetectionLevelAgainstActor(Actor* a_actor, std::uint32_t& a_LOSCount)
+		{
+			using func_t = decltype(&ProcessLists::RequestHighestDetectionLevelAgainstActor);
+			static REL::Relocation<func_t> func{ ID::ProcessLists::RequestHighestDetectionLevelAgainstActor };
+			return func(this, a_actor, a_LOSCount);
+		}
+
+		// members
+		BSSemaphore                             movementSyncSema;               // 010
+		float                                   crimeUpdateTimer;               // 018
+		float                                   removeExcessDeadTimer;          // 01C
+		std::int32_t                            numberHighActors;               // 020
+		std::int32_t                            numberFullyEnabledHighActors;   // 024
+		std::int32_t                            crimeNumber;                    // 028
+		ActorHandle                             statdetect;                     // 02C
+		bool                                    runDetection;                   // 030
+		bool                                    showDetectionStats;             // 031
+		bool                                    processHigh;                    // 032
+		bool                                    processLow;                     // 033
+		bool                                    processMHigh;                   // 034
+		bool                                    processMLow;                    // 035
+		bool                                    processSche;                    // 036
+		bool                                    showSubtitle;                   // 037
+		bool                                    updatingLowList;                // 038
+		float                                   secondsPassedNoProcess;         // 03C
+		BSTArray<ActorHandle>                   highActorHandles;               // 040
+		BSTArray<ActorHandle>                   lowActorHandles;                // 058
+		BSTArray<ActorHandle>                   middleHighActorHandles;         // 070
+		BSTArray<ActorHandle>                   middleLowActorHandles;          // 088
+		BSTArray<ActorHandle>*                  allProcesss[4];                 // 0A0
+		BSSimpleList<Crime*>*                   globalCrimes[7];                // 0C0
+		BSTArray<NiPointer<BSTempEffect>>       globalTempEffects;              // 0F8
+		BSSpinLock                              globalEffectsLock;              // 110
+		BSTArray<NiPointer<BSTempEffect>>       magicEffects;                   // 118
+		BSSpinLock                              magicEffectsLock;               // 130
+		BSTArray<NiPointer<BSTempEffect>>       interfaceEffects;               // 138
+		BSSpinLock                              interfaceEffectsLock;           // 150
+		BSSimpleList<MuzzleFlash*>              referenceMuzzleFlashes;         // 158
+		BSTArray<ObjectRefHandle>               tempShouldMoves;                // 168
+		BSSimpleList<ActorHandle>               aliveActors;                    // 180
+		BSSimpleList<ActorHandle>               idleChatterActors;              // 190
+		BSSimpleList<ActorHandle>               randomDialogueActors;           // 1A0
+		BSTArray<ActorHandle>                   initPackageLocationsQueue;      // 1B0
+		BSSpinLock                              packageLocationsQueueLock;      // 1C8
+		BSTArray<ActorHandle>                   initAnimPositionQueue;          // 1D0
+		BSTArray<BSTSmartPointer<SyncQueueObj>> syncPositionQueue;              // 1E8
+		float                                   playerActionCommentTimer;       // 200
+		float                                   playerKnockObjectCommentTimer;  // 204
+		std::uint32_t                           currentLowActor;                // 208
+		std::uint32_t                           currentMiddleHighActor;         // 20C
+		std::uint32_t                           currentMiddleLowActor;          // 210
+		bool                                    runSchedules;                   // 214
+		bool                                    runMovement;                    // 215
+		bool                                    runAnimations;                  // 216
+		bool                                    updateActorsInPlayerCell;       // 217
+	};
+	static_assert(sizeof(ProcessLists) == 0x218);
+}

plugin/lib/commonlibf4/include/RE/P/Projectile.h

@@ -0,0 +1,166 @@
+#pragma once
+
+#include "RE/B/BGSBodyPartDefs.h"
+#include "RE/B/BGSEquipIndex.h"
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/bhkCollisionQueryResultHandle.h"
+#include "RE/C/CELLJobs.h"
+#include "RE/C/CFilter.h"
+#include "RE/H/hknpBodyId.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiPointer.h"
+#include "RE/N/NiTransform.h"
+#include "RE/T/TESObjectREFR.h"
+
+namespace RE
+{
+	enum class COL_LAYER;
+	enum class ImpactResult;
+	class bhkNPCollisionObject;
+	class BSMagicShaderParticles;
+	class hknpAllHitsCollector;
+	class hknpShape;
+	class NiAVObject;
+	class NiLight;
+	class NiNode;
+	class QueuedFile;
+
+	namespace MagicSystem
+	{
+		enum class CastingSource;
+	}
+
+	class __declspec(novtable) Projectile :
+		public TESObjectREFR  // 000
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::Projectile };
+		static constexpr auto VTABLE{ VTABLE::Projectile };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kREFR };
+
+		class ImpactCreation
+		{
+		public:
+			// members
+			NiPoint3A      contactPoint;       // 00
+			NiPoint3A      contactNormal;      // 10
+			TESObjectREFR* collidee;           // 20
+			CFilter        collisionFilter;    // 28
+			hknpBodyId     collisionBodyId;    // 2C
+			std::uint32_t  collisionShapeKey;  // 30
+			bool           spellCast;          // 34
+			bool           backface;           // 35
+			bool           trigger;            // 36
+		};
+		static_assert(sizeof(ImpactCreation) == 0x40);
+
+		class ImpactData
+		{
+		public:
+			// members
+			NiPoint3                        location;                // 00
+			NiPoint3                        normal;                  // 0C
+			bhkCollisionQueryResultHandle   impactDecalQuery;        // 18
+			ObjectRefHandle                 collidee;                // 20
+			NiPointer<bhkNPCollisionObject> colObj;                  // 28
+			BGSMaterialType*                materialType;            // 30
+			BGSBodyPartDefs::LIMB_ENUM      damageLimb;              // 38
+			COL_LAYER                       collisionLayer;          // 3C
+			NiPointer<NiNode>               closestBone;             // 40
+			ImpactResult                    resultOverride;          // 48
+			float                           decalSize;               // 4C
+			std::uint32_t                   collisionShapeKey;       // 50
+			std::int16_t                    targetWorldObjectCount;  // 54
+			std::int16_t                    targetWorldObjectIndex;  // 56
+			bool                            processed;               // 58
+			bool                            spellCast;               // 59
+			bool                            effectSpawned;           // 5A
+			bool                            backface;                // 5B
+		};
+		static_assert(sizeof(ImpactData) == 0x60);
+
+		// add
+		virtual bool          IsMissileProjectile() const { return false; }                                                       // C6
+		virtual bool          IsGrenadeProjectile() const { return false; }                                                       // C7
+		virtual bool          IsFlameProjectile() const { return false; }                                                         // C8
+		virtual bool          IsBeamProjectile() const { return false; }                                                          // C9
+		virtual bool          IsFogProjectile() const { return false; }                                                           // CA
+		virtual bool          IsBarrierProjectile() const { return false; }                                                       // CB
+		virtual void          OnKill() { return; }                                                                                // CC
+		virtual void          Process3D() { return; }                                                                             // CD
+		virtual void          PostLoad3D(NiAVObject* a_obj3D);                                                                    // CE
+		virtual void          UpdateImpl(float a_delta) = 0;                                                                      // CF
+		virtual bool          ProcessImpacts();                                                                                   // D0
+		virtual void          Update3D(CELLJobs::AnimatedRefJobData* a_data);                                                     // D1
+		virtual bool          IsMine() const { return false; }                                                                    // D2
+		virtual float         GetPowerSpeedMult() const { return spell ? 1.0F : power; }                                          // D3
+		virtual float         GetWeaponSpeedMult() const { return 1.0F; }                                                         // D4
+		virtual bool          GetStopMainSoundAfterImpact() const { return false; }                                               // D5
+		virtual void          ReportHavokDeactivation() { return; }                                                               // D6
+		virtual bool          TurnOff(Actor* a_actionActor, bool a_silent);                                                       // D7
+		virtual bool          IsPermanent();                                                                                      // D8
+		virtual float         GetGravity() const;                                                                                 // D9
+		virtual void          CleanUpPointersOnDisable();                                                                         // DA
+		virtual bool          RunTargetPick();                                                                                    // DB
+		virtual bool          GetKillOnCollision() const { return true; }                                                         // DC
+		virtual bool          ShouldBeLimited() const { return false; }                                                           // DD
+		virtual bool          TargetsWholeBody() const { return false; }                                                          // DE
+		virtual bool          GetAllowMovement() const;                                                                           // DF
+		virtual std::uint32_t GetCollisionGroup() const;                                                                          // E0
+		virtual hknpShape*    GetCollisionShape();                                                                                // E1
+		virtual void          InitializeImpl() { return; }                                                                        // E2
+		virtual void          Relaunch() { return; }                                                                              // E3
+		virtual std::uint32_t AddImpact(const ImpactCreation& a_data);                                                            // E4
+		virtual bool          HandleHits(const hknpAllHitsCollector& a_collector, const NiPoint3& a_from, const NiPoint3& a_to);  // E5
+		virtual void          OnEnterTrigger() { return; }                                                                        // E6
+		virtual void          AddInitialVelocity();                                                                               // E7
+		virtual void          Handle3DLoaded() { return; }                                                                        // E8
+		virtual bool          ShouldUseDesiredTarget() { return false; }                                                          // E9
+
+		// members
+		BSTArray<ImpactData>                                     impacts;              // 110
+		NiTransform                                              followOffset;         // 130
+		NiPointer<bhkNPCollisionObject>                          collisionObject;      // 170
+		NiPointer<TESObjectREFR>                                 droppedRefr;          // 178
+		NiPoint3                                                 movementDirection;    // 180
+		NiPoint3                                                 velocity;             // 18C
+		NiPointer<NiLight>                                       light;                // 198
+		NiPointer<ActorCause>                                    actorCause;           // 1A0
+		ObjectRefHandle                                          shooter;              // 1A8
+		ObjectRefHandle                                          desiredTarget;        // 1AC
+		BSSoundHandle                                            sndHandle;            // 1B0
+		BSSoundHandle                                            sndCountdown;         // 1B8
+		BGSExplosion*                                            explosion;            // 1C0
+		MagicItem*                                               spell;                // 1C8
+		REX::TEnumSet<MagicSystem::CastingSource, std::int32_t>  castingSource;        // 1D0
+		EffectSetting*                                           avEffect;             // 1D8
+		NiPointer<QueuedFile>                                    projectileDBFiles;    // 1E0
+		void*                                                    muzzleFlashDBHandle;  // 1E8 - TODO
+		NiPointer<NiNode>                                        muzzleFlashArt;       // 1F0
+		BSMagicShaderParticles*                                  particles;            // 1F8
+		REX::TEnumSet<BGSBodyPartDefs::LIMB_ENUM, std::uint32_t> targetLimb;           // 200
+		NiPointer<NiAVObject>                                    targetLimbObj;        // 208
+		NiAVObject*                                              clonePoolKey;         // 210
+		float                                                    power;                // 218
+		float                                                    speedMult;            // 21C
+		float                                                    range;                // 220
+		float                                                    age;                  // 224
+		float                                                    damage;               // 228
+		float                                                    alpha;                // 22C
+		float                                                    explosionTimer;       // 230
+		float                                                    blinkTimer;           // 234
+		BGSObjectInstanceT<TESObjectWEAP>                        weaponSource;         // 238
+		TESAmmo*                                                 ammoSource;           // 248
+		BGSEquipIndex                                            equipIndex;           // 250
+		float                                                    distanceMoved;        // 254
+		float                                                    movementDelta;        // 258
+		float                                                    scale;                // 25C
+		std::uint64_t                                            flags;                // 260
+		bool                                                     artRequested;         // 268
+		bool                                                     animationsLoaded;     // 269
+	};
+	static_assert(sizeof(Projectile) == 0x270);
+}

plugin/lib/commonlibf4/include/RE/P/ProjectileLaunchData.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "RE/B/BGSBodyPartDefs.h"
+#include "RE/B/BGSEquipIndex.h"
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class CombatController;
+
+	namespace MagicSystem
+	{
+		enum class CastingSource;
+	}
+
+	class ProjectileLaunchData
+	{
+	public:
+		// members
+		NiPoint3                          origin;                   // 00
+		NiPoint3                          contactNormal;            // 0C
+		BGSProjectile*                    projectileBase;           // 18
+		TESObjectREFR*                    shooter;                  // 20
+		CombatController*                 shooterCombatController;  // 28
+		BGSObjectInstanceT<TESObjectWEAP> fromWeapon;               // 30
+		TESAmmo*                          fromAmmo;                 // 40
+		BGSEquipIndex                     equipIndex;               // 48
+		float                             zAngle;                   // 4C
+		float                             xAngle;                   // 50
+		float                             yAngle;                   // 54
+		TESObjectREFR*                    homingTarget;             // 58
+		TESObjectCELL*                    parentCell;               // 60
+		MagicItem*                        spell;                    // 68
+		MagicSystem::CastingSource        castingSource;            // 70
+		AlchemyItem*                      poison;                   // 78
+		std::int32_t                      area;                     // 80
+		float                             power;                    // 84
+		float                             scale;                    // 88
+		float                             coneOfFireRadiusMult;     // 8C
+		BGSBodyPartDefs::LIMB_ENUM        targetLimb;               // 90
+		bool                              alwaysHit;                // 94
+		bool                              noDamageOutsideCombat;    // 95
+		bool                              autoAim;                  // 96
+		bool                              useOrigin;                // 97
+		bool                              deferInitialization;      // 98
+		bool                              tracer;                   // 99
+		bool                              forceConeOfFire;          // 9A
+		bool                              intentionalMiss;          // 9B
+		bool                              allow3D;                  // 9C
+		bool                              penetrates;               // 9D
+		bool                              ignoreNearCollisions;     // 9E
+	};
+	static_assert(sizeof(ProjectileLaunchData) == 0xA0);
+}