docs: add plugin setup guide

2026-05-30 18:33:24 +12:00
parent f3db41c402
commit b61043a3fe
1776 changed files with 122386 additions and 2 deletions
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class LANDING_TYPE : std::uint32_t
+	{
+		kDefault = 0x0,
+		kHasty = 0x1,
+		kCrash = 0x2
+	};
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+namespace RE
+{
+	class ContainerItemExtra;
+
+	class LEVELED_OBJECT
+	{
+	public:
+		// members
+		TESForm*            form;        // 00
+		ContainerItemExtra* itemExtra;   // 08
+		std::uint16_t       count;       // 10
+		std::uint16_t       level;       // 12
+		std::int8_t         chanceNone;  // 14
+	};
+	static_assert(sizeof(LEVELED_OBJECT) == 0x18);
+}
@@ -0,0 +1,69 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTAtomicValue.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class AnimatedRefObject;
+	class BSMultiBoundNode;
+	class BSPortalGraph;
+	class NiNode;
+	class QueuedFile;
+
+	class LOADED_CELL_DATA
+	{
+	public:
+		class AnimatedRefObject
+		{
+		public:
+			// members
+			ObjectRefHandle handle;         // 0
+			std::int32_t    numSkipFrames;  // 4
+		};
+		static_assert(sizeof(AnimatedRefObject) == 0x8);
+
+		// members
+		BSTHashMap<ObjectRefHandle, TESForm*>                    emittanceSourceRefMap;      // 000
+		BSTHashMap<ObjectRefHandle, NiNode*>                     emittanceLightRefMap;       // 030
+		BSTHashMap<ObjectRefHandle, NiPointer<BSMultiBoundNode>> multiboundRefMap;           // 060
+		BSTHashMap<BSMultiBoundNode*, ObjectRefHandle>           refMultiboundMap;           // 090
+		BSTArray<NiPointer<NiNode>>                              preCombined;                // 0C0
+		BSTArray<NiPointer<NiNode>>                              attachedTransitionCells;    // 0D8
+		BSTArray<AnimatedRefObject>                              animatedRefs;               // 0F0
+		BSTArray<ObjectRefHandle>                                flickeringLights;           // 108
+		BSTArray<ObjectRefHandle>                                movingRefs;                 // 120
+		BSTArray<ObjectRefHandle>                                decalRefs;                  // 138
+		BSTArray<ObjectRefHandle>                                skyActors;                  // 150
+		BSTArray<ObjectRefHandle>                                flightAvoidAreas;           // 168
+		BSReadWriteLock                                          waterLock;                  // 180
+		void*                                                    combinedGeometry;           // 188 - TODO
+		NiPointer<QueuedFile>                                    combinedGeometryTask;       // 190
+		BSSimpleList<ObjectRefHandle>                            activatingRefs;             // 198
+		BSSimpleList<ObjectRefHandle>                            waterRefs;                  // 1A8
+		NiPointer<BSPortalGraph>                                 portalGraph;                // 1B8
+		NiPointer<NiNode>                                        cell3D;                     // 1C0
+		NiPointer<NiNode>                                        lightMarkerNode;            // 1C8
+		NiPointer<NiNode>                                        soundMarkerNode;            // 1D0
+		NiPointer<NiNode>                                        multiBoundNode;             // 1D8
+		NiPointer<NiNode>                                        combinedObjects;            // 1E0
+		NiPointer<NiNode>                                        combinedStaticCollision;    // 1E8
+		BGSEncounterZone*                                        encounterZone;              // 1F0
+		std::size_t                                              visibleDistantFadeInTime;   // 1F8
+		std::int32_t                                             criticalQueuedRefCount;     // 200
+		std::int32_t                                             queuedRefCount;             // 204
+		std::int32_t                                             queuedDistantRefCount;      // 208
+		std::uint32_t                                            refsAttachedDelay;          // 20C
+		BSTAtomicValue<std::uint32_t>                            combinedObjectsAttached;    // 210
+		bool                                                     decalsQueued;               // 214
+		bool                                                     refsFullyLoaded;            // 215
+		bool                                                     combinedObjectsRegistered;  // 216
+		bool                                                     grassIsShown;               // 217
+	};
+	static_assert(sizeof(LOADED_CELL_DATA) == 0x218);
+}
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/B/BSModelDB.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class NiAVObject;
+
+	class LOADED_REF_DATA
+	{
+	public:
+		// members
+		BSModelDB::HandelListHead handleList;           // 00
+		NiPointer<NiAVObject>     data3D;               // 08
+		TESWaterForm*             currentWaterType;     // 10
+		float                     relevantWaterHeight;  // 18
+		float                     cachedRadius;         // 1C
+		std::uint16_t             flags;                // 20
+		std::int16_t              underwaterCount;      // 22
+	};
+	static_assert(sizeof(LOADED_REF_DATA) == 0x28);
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+namespace RE
+{
+	enum class LOCK_LEVEL : std::int32_t
+	{
+		kUnlocked = static_cast<std::underlying_type_t<LOCK_LEVEL>>(-1),
+		kEasy = 0x0,
+		kAverage = 0x1,
+		kHard = 0x2,
+		kVeryHard = 0x3,
+		kRequiresKey = 0x4,
+		kInaccessible = 0x5,
+		kTerminal = 0x6,
+		kBarred = 0x7,
+		kChained = 0x8,
+	};
+}
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	namespace LevelIncrease
+	{
+		class Event
+		{
+		public:
+			// members
+			std::uint32_t newLevel;  // 00
+		};
+		static_assert(sizeof(Event) == 0x4);
+
+		[[nodiscard]] static inline BSTEventSource<LevelIncrease::Event>* GetEventSource()
+		{
+			using func_t = decltype(&LevelIncrease::GetEventSource);
+			static REL::Relocation<func_t> func{ ID::LevelIncrease::GetEventSource };
+			return func();
+		}
+	}
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSExternalAudioIO.h"
+
+namespace RE
+{
+	class LipSynchAnim
+	{
+	public:
+		// members
+		std::uint32_t                   numFrames;          // 00
+		std::int32_t                    startingFrame;      // 04
+		std::uint32_t                   numPhonemeTargets;  // 08
+		float**                         p_phonemes;         // 10
+		float**                         modifiers;          // 18
+		float*                          phonemes;           // 20
+		bool                            hasGestures;        // 28
+		std::uint32_t                   versionNumber;      // 2C
+		BSExternalAudioIO::ExternalLoad voiceData;          // 30;
+	};
+	static_assert(sizeof(LipSynchAnim) == 0x48);
+}
@@ -0,0 +1,102 @@
+#pragma once
+
+#include "RE/B/BSModelDB.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/G/GameMenuBase.h"
+#include "RE/I/ImageSpaceLUTData.h"
+#include "RE/N/NiMatrix3.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class BGSModelMaterialSwap;
+	class NiAVObject;
+
+	class __declspec(novtable) LoadingMenu :
+		public GameMenuBase  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::LoadingMenu };
+		static constexpr auto VTABLE{ VTABLE::LoadingMenu };
+		static constexpr auto MENU_NAME{ "LoadingMenu"sv };
+
+		virtual ~LoadingMenu();  // 00
+
+		// override (GameMenuBase)
+		virtual void               Call(const Params&) override;                                     // 01
+		virtual void               MapCodeObjectFunctions() override;                                // 02
+		virtual UI_MESSAGE_RESULTS ProcessMessage(UIMessage& a_message) override;                    // 03
+		virtual void               AdvanceMovie(float a_timeDelta, std::uint64_t a_time) override;   // 04
+		virtual bool               OnButtonEventRelease(const BSFixedString& a_eventName) override;  // 0F
+
+		// override (BSInputEventUser)
+		virtual bool ShouldHandleEvent(const InputEvent*) override;       // 01
+		virtual void OnThumbstickEvent(const ThumbstickEvent*) override;  // 04
+		virtual void OnButtonEvent(const ButtonEvent*) override;          // 08
+
+		static void StartTestingLoadMenu()
+		{
+			using func_t = decltype(&LoadingMenu::StartTestingLoadMenu);
+			static REL::Relocation<func_t> func{ ID::LoadingMenu::StartTestingLoadMenu };
+			return func();
+		}
+
+		void PopulateLoadScreens()
+		{
+			using func_t = decltype(&LoadingMenu::PopulateLoadScreens);
+			static REL::Relocation<func_t> func{ ID::LoadingMenu::PopulateLoadScreens };
+			return func(this);
+		}
+
+		// members
+		BGSLocation*             loadLocation;                      // 0E0
+		TESLoadScreen*           artScreen;                         // 0E8
+		std::byte                upgrader[0x10];                    // 0F0 - TODO
+		BSTArray<TESLoadScreen*> validScreens;                      // 100
+		void*                    foregroundModel;                   // 118 - BDModelDB::Handle
+		NiAVObject*              zoomTarget;                        // 120
+		ImageSpaceLUTData        LUT;                               // 128
+		std::uint32_t            numNonDefaultScreens;              // 198
+		float                    modelAggregateRotation;            // 19C
+		float                    modelMinAggregateRotation;         // 1A0
+		float                    modelMaxAggregateRotation;         // 1A4
+		float                    frameTimeDelta;                    // 1A8
+		float                    currentZoom;                       // 1AC
+		float                    minZoom;                           // 1B0
+		float                    maxZoom;                           // 1B4
+		float                    horizontalBound;                   // 1B8
+		float                    verticalBound;                     // 1BC
+		float                    verticalBoundOffset;               // 1BC
+		alignas(0x10) NiMatrix3 initialRotation;                    // 1D0
+		NiPoint2                    calcedPanMaxima;                // 200
+		NiPoint2                    calcedPanMinima;                // 208
+		std::uint64_t               lastAdvanceMovieTime;           // 210
+		std::uint64_t               lastUserInteractTime;           // 218
+		std::uint64_t               lastPanTime;                    // 220
+		std::uint64_t               lastRotationTime;               // 228
+		std::uint64_t               lastZoomTime;                   // 230
+		BSSoundHandle               rotationSoundLoop;              // 238
+		BSSoundHandle               zoomSoundLoop;                  // 240
+		const BGSModelMaterialSwap* modelMaterialSwap;              // 248
+		NiPoint3                    modelInitialRotation;           // 250
+		NiPoint3                    modelTranslationOffset;         // 25C
+		float                       modelScale;                     // 268
+		std::uint32_t               numFrames;                      // 26C
+		bool                        loadingIntoInterior;            // 270
+		bool                        menuAdded;                      // 271
+		bool                        leftButtonDown;                 // 272
+		bool                        rightButtonDown;                // 273
+		bool                        allowRotation;                  // 274
+		bool                        autoRotate;                     // 275
+		bool                        autoRotateInvert;               // 276
+		bool                        holoMode;                       // 277
+		bool                        loadScreenShown;                // 278
+		bool                        leftStickReady;                 // 279
+		bool                        rightStickReady;                // 27A
+		bool                        leftStickWasPreviouslyActive;   // 27B
+		bool                        rightStickWasPreviouslyActive;  // 27C
+		bool                        modelRequested;                 // 27D
+		bool                        PCKeysDebounced;                // 27E
+	};
+	static_assert(sizeof(LoadingMenu) == 0x280);
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class BGSLocation;
+
+	class __declspec(novtable) LoadingMenuData :
+		public IUIMessageData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::LoadingMenuData };
+		static constexpr auto VTABLE{ VTABLE::LoadingMenuData };
+
+		// members
+		BSFixedString action;    // 18
+		BGSLocation*  location;  // 20
+		bool          interior;  // 28
+	};
+	static_assert(sizeof(LoadingMenuData) == 0x30);
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	namespace LoadingStatusChanged
+	{
+		class Event
+		{
+		public:
+			bool isLoading;  // 00
+		};
+		static_assert(sizeof(Event) == 0x1);
+	}
+}
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	namespace LocalMapCameraUpdate
+	{
+		class Event
+		{
+		public:
+		};
+		static_assert(std::is_empty_v<Event>);
+	}
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	namespace LocationMarkerArrayUpdate
+	{
+		class Event
+		{
+		public:
+			bool shouldClearMapMarkers;  // 00
+		};
+		static_assert(sizeof(Event) == 0x1);
+	}
+}
@@ -0,0 +1,86 @@
+#pragma once
+
+#include "RE/B/BSSoundHandle.h"
+#include "RE/G/GameMenuBase.h"
+#include "RE/N/NiMatrix3.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class NiControllerManager;
+	class NiControllerSequence;
+	class NiNode;
+
+	class __declspec(novtable) LockpickingMenu :
+		public GameMenuBase  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::LockpickingMenu };
+		static constexpr auto VTABLE{ VTABLE::LockpickingMenu };
+		static constexpr auto MENU_NAME{ "LockpickingMenu"sv };
+
+		virtual ~LockpickingMenu();  // 00
+
+		// override (GameMenuBase)
+		virtual UI_MESSAGE_RESULTS ProcessMessage(UIMessage& a_message) override;                    // 03
+		virtual void               AdvanceMovie(float a_timeDelta, std::uint64_t a_time) override;   // 04
+		virtual bool               OnButtonEventRelease(const BSFixedString& a_eventName) override;  // 0F
+
+		// override (BSInputEventUser)
+		virtual bool ShouldHandleEvent(const InputEvent*) override;       // 01
+		virtual void OnThumbstickEvent(const ThumbstickEvent*) override;  // 04
+		virtual void OnMouseMoveEvent(const MouseMoveEvent*) override;    // 06
+		virtual void OnButtonEvent(const ButtonEvent*) override;          // 08
+
+		static void OpenLockpickingMenu(TESObjectREFR* a_lockedRef)
+		{
+			using func_t = decltype(&LockpickingMenu::OpenLockpickingMenu);
+			static REL::Relocation<func_t> func{ ID::LockpickingMenu::OpenLockpickingMenu };
+			return func(a_lockedRef);
+		}
+
+		static void DamageLockpick()
+		{
+			using func_t = decltype(&LockpickingMenu::DamageLockpick);
+			static REL::Relocation<func_t> func{ ID::LockpickingMenu::DamageLockpick };
+			return func();
+		}
+
+		// members
+		NiMatrix3             origPickRotate;           // 0E0
+		NiPoint3              origPickTranslate;        // 110
+		NiControllerManager*  lockAnimManager;          // 120
+		NiControllerSequence* lockIntroAnim;            // 128
+		NiControllerSequence* lockRotateAnim;           // 130
+		NiControllerManager*  pickAnimManager;          // 138
+		NiControllerSequence* pickIntroAnim;            // 140
+		NiControllerSequence* pickBendAnim;             // 148
+		NiControllerSequence* pickBreakAnim;            // 150
+		NiControllerSequence* currPickAnim;             // 158
+		NiControllerSequence* currLockAnim;             // 160
+		void*                 lockModel;                // 168
+		void*                 pickModel;                // 170
+		NiPointer<NiNode>     lockRoot;                 // 178
+		float                 currPickAnimElapsedSecs;  // 180
+		float                 currLockAnimElapsedSecs;  // 184
+		float                 pickAngle;                // 188
+		float                 lockAngle;                // 18C
+		float                 lockDamagePickAngle;      // 190
+		float                 pickBreakSecs;            // 194
+		BSSoundHandle         pickTensionSound;         // 198
+		float                 sweetSpotCenter;          // 1A0
+		float                 sweetSpotLength;          // 1A4
+		float                 partialPickLength;        // 1A8
+		std::uint32_t         picksBroken;              // 1AC
+		bool                  modelsInit;               // 1B0
+		bool                  animating;                // 1B1
+		bool                  turningLock;              // 1B2
+		bool                  menuCleanedUp;            // 1B3
+		bool                  tutorialMenuOpening;      // 1B4
+		bool                  crimeDetected;            // 1B5
+		bool                  VATSWasEnabled;           // 1B6
+		bool                  VATSDepthTestMask;        // 1B7
+	};
+	static_assert(sizeof(LockpickingMenu) == 0x1C0);
+}
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class LocksPicked
+	{
+	public:
+		class Event
+		{
+		public:
+		};
+		static_assert(std::is_empty_v<LocksPicked::Event>);
+
+		[[nodiscard]] static BSTEventSource<LocksPicked::Event>* GetEventSource()
+		{
+			using func_t = decltype(&LocksPicked::GetEventSource);
+			static REL::Relocation<func_t> func{ ID::LocksPicked::GetEventSource };
+			return func();
+		}
+	};
+	static_assert(std::is_empty_v<LocksPicked>);
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/P/PlayerInputHandler.h"
+
+namespace RE
+{
+	class LookHandler :
+		public PlayerInputHandler
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::LookHandler };
+		static constexpr auto VTABLE{ VTABLE::LookHandler };
+
+		explicit constexpr LookHandler(PlayerControlsData& a_data) noexcept :
+			PlayerInputHandler(a_data)
+		{}
+
+		// members
+		float thumbstickMaxedSec{ 0.0f };  // 20
+	};
+	static_assert(sizeof(LookHandler) == 0x28);
+}