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,60 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	enum class BIPED_OBJECT;
+	enum class RACE_SIZE;
+
+	class RACE_DATA
+	{
+	public:
+		// members
+		float             height[2];                    // 000
+		NiPoint3          weight[2];                    // 008
+		std::int32_t      flags;                        // 020
+		float             accelerate;                   // 024
+		float             decelerate;                   // 028
+		RACE_SIZE         raceSize;                     // 02C
+		BIPED_OBJECT      headObject;                   // 030
+		BIPED_OBJECT      hairObject;                   // 034
+		BIPED_OBJECT      beardObject;                  // 038
+		float             injuredHealthPercent;         // 03C
+		BIPED_OBJECT      shieldObject;                 // 040
+		BIPED_OBJECT      bodyObject;                   // 044
+		float             aimAngleTolerance;            // 048
+		float             flightRadius;                 // 04C
+		float             angleAccelerate;              // 050
+		float             angleTolerance;               // 054
+		std::uint32_t     flags2;                       // 058
+		NiPoint3          mountOffset;                  // 05C
+		NiPoint3          dismountOffset;               // 068
+		NiPoint3          mountCameraOffset;            // 074
+		BIPED_OBJECT      pipboyObject;                 // 080
+		std::int16_t      xpValue;                      // 084
+		BGSExplosion*     onCrippleExplosion;           // 088
+		BGSDebris*        onCrippleGenericDebris;       // 090
+		BGSImpactDataSet* onCrippleImpactDataSet;       // 098
+		float             onCrippleGenericDebrisScale;  // 0A0
+		std::int8_t       onCrippleGenericDebrisCount;  // 0A4
+		std::int8_t       onCrippleDecalCount;          // 0A5
+		BGSExplosion*     dismemberExplosion;           // 0A8
+		BGSDebris*        dismemberGenericDebris;       // 0B0
+		BGSImpactDataSet* dismemberImpactDataSet;       // 0B8
+		float             dismemberGenericDebrisScale;  // 0C0
+		std::int8_t       dismemberGenericDebrisCount;  // 0C4
+		std::int8_t       dismemberDecalCount;          // 0C5
+		BGSExplosion*     explosion;                    // 0C8
+		BGSDebris*        explosionGenericDebris;       // 0D0
+		BGSImpactDataSet* explosionImpactDataSet;       // 0D8
+		float             explosionGenericDebrisScale;  // 0E0
+		std::int8_t       explosionGenericDebrisCount;  // 0E4
+		std::int8_t       explosionDecalCount;          // 0E5
+		BGSExplosion*     subsegmentExplosion;          // 0E8
+		float             maxPitch;                     // 0F0
+		float             maxRoll;                      // 0F4
+		float             defaultHeadHeight;            // 0F8
+	};
+	static_assert(sizeof(RACE_DATA) == 0x100);
+}
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class RACE_SIZE : std::int32_t
+	{
+		kSmall = 0,
+		kMedium = 1,
+		kLarge = 2,
+		kExtraLarge = 3
+	};
+}
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	class RADIO_DATA
+	{
+	public:
+		// members
+		float radioStation;         // 00
+		float minWeakSignalRange;   // 04
+		float maxWeakSignalRange;   // 08
+		bool  ignoreDistanceChekc;  // 0C
+	};
+	static_assert(sizeof(RADIO_DATA) == 0x10);
+}
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class RADIO_RANGE_TYPE
+	{
+		kRadius = 0x0,
+		kEverywhere = 0x1,
+		kWorldspace = 0x2,
+		kLinkedInt = 0x3,
+		kCurrentCell = 0x4
+	};
+}
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "RE/B/BGSLocalizedString.h"
+#include "RE/T/TESTexture.h"
+
+namespace RE
+{
+	class RANK_DATA
+	{
+	public:
+		// members
+		BGSLocalizedString maleRankTitle;    // 00
+		BGSLocalizedString femaleRankTitle;  // 08
+		TESTexture         textureInsignia;  // 10
+	};
+	static_assert(sizeof(RANK_DATA) == 0x20);
+}
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class RECOIL_ENUM
+	{
+		kNone = 0x0,
+		kSmall = 0x1,
+		kLarge = 0x2
+	};
+}
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class BSLight;
+	class NiLight;
+
+	class REFR_LIGHT
+	{
+	public:
+		// members
+		NiPointer<NiLight> light;       // 00
+		NiPointer<BSLight> BSLight;     // 08
+		float              wantDimmer;  // 10
+	};
+	static_assert(sizeof(REFR_LIGHT) == 0x18);
+}
@@ -0,0 +1,51 @@
+#pragma once
+
+namespace RE
+{
+	enum class LOCK_LEVEL;
+
+	class REFR_LOCK
+	{
+	public:
+		enum class Flags : std::uint8_t
+		{
+			kLocked = 0x1,
+			kLeveled = 0x4
+		};
+
+		[[nodiscard]] LOCK_LEVEL GetLockLevel(TESObjectREFR* a_owner)
+		{
+			using func_t = decltype(&REFR_LOCK::GetLockLevel);
+			static REL::Relocation<func_t> func{ ID::REFR_LOCK::GetLockLevel };
+			return func(this, a_owner);
+		}
+
+		void SetLocked(bool a_locked)
+		{
+			using func_t = decltype(&REFR_LOCK::SetLocked);
+			static REL::Relocation<func_t> func{ ID::REFR_LOCK::SetLocked };
+			return func(this, a_locked);
+		}
+
+		bool IsBroken()
+		{
+			using func_t = decltype(&REFR_LOCK::IsBroken);
+			static REL::Relocation<func_t> func{ ID::REFR_LOCK::IsBroken };
+			return func(this);
+		}
+
+		[[nodiscard]] static LOCK_LEVEL NumericValueToEnum(std::int32_t a_value)
+		{
+			using func_t = decltype(&REFR_LOCK::NumericValueToEnum);
+			static REL::Relocation<func_t> func{ ID::REFR_LOCK::NumericValueToEnum };
+			return func(a_value);
+		}
+
+		// members
+		std::uint8_t  baseLevel;  // 00
+		TESKey*       key;        // 08
+		std::uint8_t  flags;      // 10
+		std::uint32_t numTries;   // 14
+	};
+	static_assert(sizeof(REFR_LOCK) == 0x18);
+}
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/R/REGION_DATA_ID.h"
+
+namespace RE
+{
+	class REGION_DATA_BASE
+	{
+	public:
+		// members
+		REGION_DATA_ID dataTypeID;  // 00
+		bool           override;    // 04
+		std::uint8_t   priority;    // 05
+	};
+	static_assert(sizeof(REGION_DATA_BASE) == 0x8);
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+namespace RE
+{
+	enum class REGION_DATA_ID : std::uint32_t
+	{
+		kNone = 0x0,
+		kGeneralID = 0x1,
+		kObjectsID = 0x2,
+		kWeatherID = 0x3,
+		kMapID = 0x4,
+		kLandscapeID = 0x5,
+		kGrassID = 0x6,
+		kSoundID = 0x7,
+
+		kTotal = 0x8
+	};
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+namespace RE
+{
+	enum class RESET_3D_FLAGS : std::int32_t
+	{
+		kModel = 1u << 0,
+		kSkin = 1u << 1,
+		kHead = 1u << 2,
+		kFace = 1u << 3,
+		kScale = 1u << 4,
+		kSkeleton = 1u << 5,
+		kInitDefault = 1u << 6,
+		kSkyCellSkin = 1u << 7,
+		kHavok = 1u << 8,
+		kDontAddOutfit = 1u << 9,
+		kKeepHead = 1u << 10,
+		kDismemberment = 1u << 11
+	};
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+namespace RE
+{
+	namespace RadioManager
+	{
+		inline bool QPlayerRadioEnabled()
+		{
+			using func_t = decltype(&RadioManager::QPlayerRadioEnabled);
+			static REL::Relocation<func_t> func{ ID::RadioManager::QPlayerRadioEnabled };
+			return func();
+		}
+
+		inline float QCurrentPlayerFreq()
+		{
+			using func_t = decltype(&RadioManager::QCurrentPlayerFreq);
+			static REL::Relocation<func_t> func{ ID::RadioManager::QCurrentPlayerFreq };
+			return func();
+		}
+
+		inline void EnablePlayerRadio(bool a_enable, bool a_playOnOffSound)
+		{
+			using func_t = decltype(&RadioManager::EnablePlayerRadio);
+			static REL::Relocation<func_t> func{ ID::RadioManager::EnablePlayerRadio };
+			return func(a_enable, a_playOnOffSound);
+		}
+	}
+}
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class RagDollBone
+	{
+	public:
+		// members
+		char     boneID;   // 00
+		NiPoint3 bonePos;  // 04
+		NiPoint3 boneRot;  // 10
+	};
+	static_assert(sizeof(RagDollBone) == 0x1C);
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class RagDollBone;
+
+	class RagDollData
+	{
+	public:
+		// members
+		std::uint8_t boneCount;  // 00
+		RagDollBone* boneArray;  // 08
+		NiPoint3     bip01Rot;   // 10
+	};
+	static_assert(sizeof(RagDollData) == 0x20);
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/P/PlayerInputHandler.h"
+
+namespace RE
+{
+	class ReadyWeaponHandler :
+		public PlayerInputHandler
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ReadyWeaponHandler };
+		static constexpr auto VTABLE{ VTABLE::ReadyWeaponHandler };
+
+		explicit constexpr ReadyWeaponHandler(PlayerControlsData& a_data) noexcept :
+			PlayerInputHandler(a_data)
+		{}
+
+		// members
+		bool actionTaken{ false };  // 20
+	};
+	static_assert(sizeof(ReadyWeaponHandler) == 0x28);
+}
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+
+namespace RE
+{
+	class MagicItem;
+
+	class ReanimateData
+	{
+	public:
+		// members
+		ActorHandle caster;          // 00
+		MagicItem*  reanimateSpell;  // 08
+	};
+	static_assert(sizeof(ReanimateData) == 0x10);
+}
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/A/AttachTechniqueInput.h"
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class bhkWorld;
+
+	class __declspec(novtable) RefAttachTechniqueInput :
+		public BSAttachTechniques::AttachTechniqueInput  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::RefAttachTechniqueInput };
+		static constexpr auto VTABLE{ VTABLE::RefAttachTechniqueInput };
+
+		// members
+		TESObjectREFR* object;           // 20
+		TESRace*       race;             // 28
+		bhkWorld*      havokWorld;       // 30
+		std::uint32_t  collisionGroup;   // 38
+		BSFixedString  techniqueSuffix;  // 40
+	};
+	static_assert(sizeof(RefAttachTechniqueInput) == 0x48);
+}
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSTempEffect.h"
+
+namespace RE
+{
+	class NiAVObject;
+	class ReferenceEffectController;
+
+	class __declspec(novtable) ReferenceEffect :
+		public BSTempEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ReferenceEffect };
+		static constexpr auto VTABLE{ VTABLE::ReferenceEffect };
+		static constexpr auto Ni_RTTI{ Ni_RTTI::ReferenceEffect };
+		static constexpr auto TYPE{ TEMP_EFFECT_TYPE::kRefDefault };
+
+		~ReferenceEffect() override;
+
+		// add
+		virtual bool        Init();                                // 37
+		virtual void        Suspend();                             // 38
+		virtual void        Resume();                              // 39
+		virtual void        Update3D();                            // 3A
+		virtual void        ClearTarget();                         // 3B
+		virtual void        UpdateParentCell(NiAVObject* a_root);  // 3C
+		virtual void        UpdatePosition();                      // 3D
+		virtual NiAVObject* GetAttachRoot();                       // 3E
+		virtual bool        GetAttached();                         // 3F
+		virtual void        DetachImpl();                          // 40
+
+		// members
+		ReferenceEffectController* controller;     // 30
+		ObjectRefHandle            target;         // 38
+		ObjectRefHandle            aimAtTarget;    // 3C
+		bool                       finished;       // 40
+		bool                       ownController;  // 41
+	};
+	static_assert(sizeof(ReferenceEffect) == 0x48);
+}
@@ -0,0 +1,59 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class BGSLoadGameBuffer;
+	class BGSSaveGameBuffer;
+	class NiAVObject;
+	class NiNode;
+	class NiPoint3;
+	class ReferenceEffect;
+
+	class __declspec(novtable) ReferenceEffectController
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ReferenceEffectController };
+		static constexpr auto VTABLE{ VTABLE::ReferenceEffectController };
+
+		virtual ~ReferenceEffectController();  // 00
+
+		// add
+		virtual void             HandleEvent(const BSFixedString& a_event);                 // 01 - { return; }
+		virtual float            GetElapsedTime();                                          // 02 - { return 0.0; }
+		virtual float            GetScale();                                                // 03 - { return 1.0; }
+		virtual void             SwitchAttachedRoot(NiNode* a_root, NiNode* a_attachRoot);  // 04 - { return; }
+		virtual const NiPoint3&  GetSourcePosition();                                       // 05 - { return NiPoint3(); }
+		virtual bool             GetUseSourcePosition();                                    // 06 - { return true; }
+		virtual bool             GetNoInitialFlare();                                       // 07 - { return false; }
+		virtual bool             GetEffectPersists();                                       // 08 - { return true; }
+		virtual bool             GetGoryVisuals();                                          // 09 - { return false; }
+		virtual void             RemoveHitEffect(ReferenceEffect* a_refEffect);             // 0A - { return; }
+		virtual TESObjectREFR*   GetTargetReference() = 0;                                  // 0B
+		virtual BGSArtObject*    GetHitEffectArt() = 0;                                     // 0C
+		virtual TESEffectShader* GetHitEffectShader() = 0;                                  // 0D
+		virtual bool             GetManagerHandlesSaveLoad() = 0;                           // 0E
+		virtual NiAVObject*      GetAttachRoot();                                           // 0F - { auto ref = GetTargetReference(); return ref ? ref->Get3D() : 0; }
+		virtual float            GetParticleAttachExtent();                                 // 10 - { return 0.0; }
+		virtual bool             GetUseParticleAttachExtent();                              // 11 - { return false; }
+		virtual bool             GetDoParticles();                                          // 12 - { return true; }
+		virtual bool             GetParticlesUseLocalSpace();                               // 13 - { return false; }
+		virtual bool             GetUseRootWorldRotate();                                   // 14 - { return false; }
+		virtual bool             GetIsRootActor();                                          // 15 - { auto ref = GetTargetReference(); return ref ? ref->formType = FormType::ActorCharacter : false; }
+		virtual bool             GetClearWhenCellIsUnloaded();                              // 16 - { return false; }
+		virtual bool             EffectShouldFaceTarget();                                  // 17 - { return false; }
+		virtual TESObjectREFR*   GetFacingTarget();                                         // 18 - { return 0; }
+		virtual bool             GetShaderUseParentCell();                                  // 19 - { return true; }
+		virtual bool             EffectAttachesToCamera();                                  // 1A - { return false; }
+		virtual bool             EffectRotatesWithCamera();                                 // 1B - { return false; }
+		virtual bool             GetAllowTargetRoot();                                      // 1C - { return true; }
+		virtual bool             IsReadyForAttach();                                        // 1D - { return true; }
+		virtual void             SetWindPoint(const NiPoint3& a_point);                     // 1E - { return; }
+		virtual const NiPoint3&  GetWindPoint();                                            // 1F - { return NiPoint3(); }
+		virtual bool             GetAllowNo3D();                                            // 20 - { return false; }
+		virtual void             SaveGame(BGSSaveGameBuffer* a_buf);                        // 21 - { return; }
+		virtual void             LoadGame(BGSLoadGameBuffer* a_buf);                        // 22 - { return; }
+	};
+	static_assert(sizeof(ReferenceEffectController) == 0x8);
+}
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class RelativeMarkerHeight : std::int32_t
+	{
+		kInvalid = 0x0,
+		kBelowPlayer = 0x1,
+		kLevelWithPlayer = 0x2,
+		kAbovePlayer = 0x3
+	};
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/E/ExamineConfirmMenu.h"
+
+namespace RE
+{
+	class __declspec(novtable) RepairFailureCallback :
+		public ExamineConfirmMenu::ICallback  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::__RepairFailureCallback };
+		static constexpr auto VTABLE{ VTABLE::__RepairFailureCallback };
+
+		RepairFailureCallback(ExamineMenu* a_thisMenu) :
+			ExamineConfirmMenu::ICallback(a_thisMenu)
+		{
+			REX::EMPLACE_VTABLE(this);
+		}
+
+		virtual ~RepairFailureCallback() = default;  // 00
+
+		// override
+		virtual void OnAccept() override;  // 01
+
+		F4_HEAP_REDEFINE_NEW(RepairFailureCallback);
+	};
+	static_assert(sizeof(RepairFailureCallback) == 0x10);
+}
@@ -0,0 +1,17 @@
+#pragma once
+
+namespace RE
+{
+	namespace TESSoundDefs
+	{
+		class RepeaterData
+		{
+		public:
+			// members
+			float minDelay;   // 0
+			float maxDelay;   // 4
+			bool  stackable;  // 8
+		};
+		static_assert(sizeof(RepeaterData) == 0xC);
+	}
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	class TESResponse;
+
+	class ResponseListWrapper
+	{
+	public:
+		// members
+		TESResponse* head;  // 0
+	};
+	static_assert(sizeof(ResponseListWrapper) == 0x8);
+}
@@ -0,0 +1,29 @@
+#pragma once
+
+namespace RE
+{
+	class Rumble
+	{
+	public:
+		enum RUMBLE_TYPE : std::uint32_t
+		{
+			kBigMotor = 0x0,
+			kSmallMotor = 0x1
+		};
+
+		enum RUMBLE_PATTERN : std::uint32_t
+		{
+			kConstant = 0x0,
+			kPeriodicSquare = 0x1,
+			kPeriodicTriangle = 0x2,
+			kPeriodicSawtooth = 0x3,
+		};
+
+		class AutoRumblePause
+		{
+		public:
+		};
+		static_assert(std::is_empty_v<AutoRumblePause>);
+	};
+	static_assert(std::is_empty_v<Rumble>);
+}