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,78 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTSmartPointer.h"
+
+namespace RE
+{
+	class BSAnimationGraphChannel;
+	class BSAnimationGraphManager;
+	class BShkbAnimationGraph;
+	class NiAVObject;
+
+	class __declspec(novtable) IAnimationGraphManagerHolder
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IAnimationGraphManagerHolder };
+		static constexpr auto VTABLE{ VTABLE::IAnimationGraphManagerHolder };
+
+		virtual ~IAnimationGraphManagerHolder() = default;  // 00
+
+		// add
+		virtual bool          NotifyAnimationGraphImpl(const BSFixedString& a_eventName);                                                                                                                                                     // 01
+		virtual void          EventSuccessfullyProcessed() { return; }                                                                                                                                                                        // 02
+		virtual void          ModifyInitialAnimationStateImpl(const bool) { return; }                                                                                                                                                         // 03
+		virtual bool          GetAnimationGraphManagerImpl(BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) const = 0;                                                                                                               // 04
+		virtual bool          SetAnimationGraphManagerImpl(const BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) = 0;                                                                                                               // 05
+		virtual bool          PopulateGraphNodesToTarget([[maybe_unused]] BSScrapArray<NiAVObject*>& a_nodesToAnimate) const { return false; }                                                                                                // 06
+		virtual bool          ConstructAnimationGraph(BSTSmartPointer<BShkbAnimationGraph>& a_animGraph) = 0;                                                                                                                                 // 07
+		virtual bool          InitializeAnimationGraphVariables([[maybe_unused]] const BSTSmartPointer<BShkbAnimationGraph>& a_newGraph) const { return true; }                                                                               // 08
+		virtual bool          SetupAnimEventSinks([[maybe_unused]] const BSTSmartPointer<BShkbAnimationGraph>& a_newGraph) { return true; }                                                                                                   // 09
+		virtual void          DoFailedToLoadGraph() const { return; }                                                                                                                                                                         // 0A
+		virtual bool          CreateAnimationChannels([[maybe_unused]] BSScrapArray<BSTSmartPointer<BSAnimationGraphChannel>>& a_channels) { return false; }                                                                                  // 0B
+		virtual void          PostCreateAnimationGraphManager([[maybe_unused]] BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) { return; }                                                                                          // 0C
+		virtual void          PostChangeAnimationManager([[maybe_unused]] const BSTSmartPointer<BSAnimationGraphManager>& a_newAnimGraphMgr, [[maybe_unused]] const BSTSmartPointer<BSAnimationGraphManager>& a_oldAnimGraphMgr) { return; }  // 0D
+		virtual bool          ShouldUpdateAnimation() { return true; }                                                                                                                                                                        // 0E
+		virtual std::uint32_t GetGraphVariableCacheSize() const { return 0; }                                                                                                                                                                 // 0F
+		virtual bool          GetGraphVariableImpl([[maybe_unused]] std::uint32_t a_graphVarID, [[maybe_unused]] float& a_out) const { return false; }                                                                                        // 10
+		virtual bool          GetGraphVariableImpl([[maybe_unused]] std::uint32_t a_graphVarID, [[maybe_unused]] bool& a_out) const { return false; }                                                                                         // 11
+		virtual bool          GetGraphVariableImpl([[maybe_unused]] std::uint32_t a_graphVarID, [[maybe_unused]] std::int32_t& a_out) const { return false; }                                                                                 // 12
+		virtual bool          GetGraphVariableImplFloat(const BSFixedString& a_variable, float& a_out) const;                                                                                                                                 // 13
+		virtual bool          GetGraphVariableImplInt(const BSFixedString& a_variable, std::int32_t& a_out) const;                                                                                                                            // 14
+		virtual bool          GetGraphVariableImplBool(const BSFixedString& a_variable, bool& a_out) const;                                                                                                                                   // 15
+		virtual void          PreUpdateAnimationGraphManager([[maybe_unused]] const BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) const { return; }                                                                               // 16
+		virtual void          PostUpdateAnimationGraphManager([[maybe_unused]] const BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) const { return; }                                                                              // 17
+		virtual void          PreLoadAnimationGraphManager([[maybe_unused]] const BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) { return; }                                                                                       // 18
+		virtual void          PostLoadAnimationGraphManager([[maybe_unused]] const BSTSmartPointer<BSAnimationGraphManager>& a_animGraphMgr) { return; }                                                                                      // 19
+
+		bool SetGraphVariableBool(const BSFixedString& a_variable, bool a_var)
+		{
+			using func_t = decltype(&IAnimationGraphManagerHolder::SetGraphVariableBool);
+			static REL::Relocation<func_t> func{ ID::IAnimationGraphManagerHolder::SetGraphVariableBool };
+			return func(this, a_variable, a_var);
+		};
+
+		bool SetGraphVariableFloat(const BSFixedString& a_variable, float a_var)
+		{
+			using func_t = decltype(&IAnimationGraphManagerHolder::SetGraphVariableFloat);
+			static REL::Relocation<func_t> func{ ID::IAnimationGraphManagerHolder::SetGraphVariableFloat };
+			return func(this, a_variable, a_var);
+		};
+
+		bool SetGraphVariableInt(const BSFixedString& a_variable, int a_var)
+		{
+			using func_t = decltype(&IAnimationGraphManagerHolder::SetGraphVariableInt);
+			static REL::Relocation<func_t> func{ ID::IAnimationGraphManagerHolder::SetGraphVariableInt };
+			return func(this, a_variable, a_var);
+		};
+
+		bool RevertAnimationGraphManager(bool a_performModifyInitialAnimationStateC = true)
+		{
+			using func_t = decltype(&IAnimationGraphManagerHolder::RevertAnimationGraphManager);
+			static REL::Relocation<func_t> func{ ID::IAnimationGraphManagerHolder::RevertAnimationGraphManager };
+			return func(this, a_performModifyInitialAnimationStateC);
+		}
+	};
+	static_assert(sizeof(IAnimationGraphManagerHolder) == 0x8);
+}
@@ -0,0 +1,45 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/I/InputEvent.h"
+
+namespace RE
+{
+	class __declspec(novtable) IDEvent :
+		public InputEvent  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IDEvent };
+		static constexpr auto VTABLE{ VTABLE::IDEvent };
+
+		// NOLINTNEXTLINE(modernize-use-override)
+		virtual ~IDEvent() = default;  // 00
+
+		// override (InputEvent)
+		bool HasIDCode() const override { return true; }  // 02
+
+		const BSFixedString& QUserEvent() const override  // 03
+		{
+			if (!disabled) {
+				return strUserEvent;
+			}
+
+			static const BSFixedString DISABLED{ "DISABLED" };
+
+			return DISABLED;
+		}
+
+		[[nodiscard]] const bool           QDisabled() const noexcept { return disabled; }
+		[[nodiscard]] const std::uint32_t  QIDCode() const noexcept { return idCode; }
+		[[nodiscard]] const BSFixedString& QRawUserEvent() const noexcept { return strUserEvent; }
+
+		// members
+		BSFixedString strUserEvent;       // 28
+		std::int32_t  idCode{ -1 };       // 30
+		bool          disabled{ false };  // 34
+	};
+	static_assert(sizeof(IDEvent) == 0x38);
+
+	extern template IDEvent*       InputEvent::As();
+	extern template const IDEvent* InputEvent::As() const;
+}
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	class IDLE_DATA
+	{
+	public:
+		// members
+		std::int8_t   loopMin;      // 0
+		std::int8_t   loopMax;      // 1
+		std::int8_t   flags;        // 2
+		std::uint16_t replayDelay;  // 4
+	};
+	static_assert(sizeof(IDLE_DATA) == 0x6);
+}
@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	class TESIdleForm;
+
+	class IDLE_REPLAY_DELAY
+	{
+	public:
+		// memberse
+		const TESIdleForm* idleForm;  // 00
+		float              delay;     // 08
+	};
+	static_assert(sizeof(IDLE_REPLAY_DELAY) == 0x10);
+}
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSIntrusiveRefCounted.h"
+
+namespace RE
+{
+	class BSStorage;
+
+	namespace REFREventCallbacks
+	{
+		class IEventCallback :
+			public BSIntrusiveRefCounted  // 00
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::REFREventCallbacks__IEventCallback };
+			static constexpr auto VTABLE{ VTABLE::REFREventCallbacks__IEventCallback };
+
+			virtual ~IEventCallback();  // 00
+
+			// add
+			virtual void                 operator()() = 0;                  // 01
+			virtual bool                 Save(BSStorage& a_storage);        // 02
+			virtual const BSFixedString* GetType() = 0;                     // 03
+			virtual bool                 Load(const BSStorage& a_storage);  // 04
+		};
+		static_assert(sizeof(IEventCallback) == 0x10);
+	}
+}
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RE/E/ENUM_FORM_ID.h"
+
+namespace RE
+{
+	enum class OBJECT_CATEGORY_TYPE;
+	enum class OBJECT_TYPE;
+
+	class __declspec(novtable) IFormFactory
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IFormFactory };
+		static constexpr auto VTABLE{ VTABLE::IFormFactory };
+
+		virtual ~IFormFactory();  // 00
+
+		// add
+		[[nodiscard]] virtual TESForm*                   DoCreate() = 0;                                // 01
+		[[nodiscard]] virtual const char*                GetFormName() const = 0;                       // 02
+		[[nodiscard]] virtual ENUM_FORM_ID               GetFormID() const = 0;                         // 03
+		[[nodiscard]] virtual const char*                GetObjectName() const { return nullptr; }      // 04
+		[[nodiscard]] virtual OBJECT_TYPE                GetObjectType() const;                         // 05
+		[[nodiscard]] virtual OBJECT_CATEGORY_TYPE       GetObjectCategory() const;                     // 06
+		[[nodiscard]] virtual BGSMod::Property::BridgeI* GetPropertyBridge() const { return nullptr; }  // 07
+
+		[[nodiscard]] static auto GetFormFactories()
+			-> std::span<IFormFactory*, std::to_underlying(ENUM_FORM_ID::kTotal)>
+		{
+			constexpr auto                                len = std::to_underlying(ENUM_FORM_ID::kTotal);
+			static REL::Relocation<IFormFactory*(*)[len]> factories{ ID::IFormFactory::Factories };
+			return { *factories };
+		}
+	};
+	static_assert(sizeof(IFormFactory) == 0x8);
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class __declspec(novtable) IKeywordFormBase
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IKeywordFormBase };
+		static constexpr auto VTABLE{ VTABLE::IKeywordFormBase };
+
+		virtual ~IKeywordFormBase() = default;  // 00
+
+		// add
+		virtual bool HasKeyword(const BGSKeyword* a_keyword, const TBO_InstanceData* a_data = nullptr) const = 0;                   // 01
+		virtual void CollectAllKeywords(BSScrapArray<const BGSKeyword*>& a_outKeywords, const TBO_InstanceData* a_data) const = 0;  // 02
+	};
+	static_assert(sizeof(IKeywordFormBase) == 0x8);
+}
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "RE/I/IMemoryStore.h"
+
+namespace RE
+{
+	enum class MEM_CONTEXT;
+
+	class HeapStats;
+
+	class __declspec(novtable) IMemoryHeap :
+		public IMemoryStore  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMemoryHeap };
+		static constexpr auto VTABLE{ VTABLE::IMemoryHeap };
+
+		// NOLINTNEXTLINE(modernize-use-override)
+		virtual ~IMemoryHeap() = default;
+
+		// override (IMemoryStore)
+		bool  ContainsBlockImpl(const void* a_block) const override { return PointerInHeap(a_block); }                             // 03
+		void* AllocateAlignImpl(std::size_t a_size, std::uint32_t a_alignment) override { return Allocate(a_size, a_alignment); }  // 04
+		void  DeallocateAlignImpl(void*& a_block) override { Deallocate(a_block, 0); }                                             // 05
+
+		// add
+		virtual const char*   GetName() const = 0;                                                      // 07
+		virtual void*         Allocate(std::size_t a_size, std::uint32_t a_alignment) = 0;              // 08
+		virtual void          Deallocate(void* a_mem, std::uint32_t) = 0;                               // 09
+		virtual bool          PointerInHeap(const void* a_pointer) const = 0;                           // 0A
+		virtual std::size_t   TotalSize(const void* a_pointer) const = 0;                               // 0B
+		virtual void          GetHeapStats(HeapStats* a_stats, bool a_fullBlockInfo) = 0;               // 0C
+		virtual bool          ShouldTrySmallBlockPools(std::size_t a_size, MEM_CONTEXT a_context) = 0;  // 0D
+		virtual std::uint32_t GetPageSize() const = 0;                                                  // 0E
+	};
+	static_assert(sizeof(IMemoryHeap) == 0x8);
+}
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "RE/I/IMemoryStoreBase.h"
+
+namespace RE
+{
+	class __declspec(novtable) IMemoryStore :
+		public IMemoryStoreBase  // 0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMemoryStore };
+		static constexpr auto VTABLE{ VTABLE::IMemoryStore };
+
+		// NOLINTNEXTLINE(modernize-use-override)
+		virtual ~IMemoryStore() = default;  // 00
+
+		// add
+		virtual void* AllocateAlignImpl(std::size_t a_size, std::uint32_t a_alignment) = 0;                                                 // 04
+		virtual void  DeallocateAlignImpl(void*& a_block) = 0;                                                                              // 05
+		virtual void* TryAllocateImpl([[maybe_unused]] std::size_t a_size, [[maybe_unused]] std::uint32_t a_alignment) { return nullptr; }  // 06
+	};
+	static_assert(sizeof(IMemoryStore) == 0x8);
+}
@@ -0,0 +1,21 @@
+#pragma once
+
+namespace RE
+{
+	class MemoryStats;
+
+	class __declspec(novtable) IMemoryStoreBase
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMemoryStoreBase };
+		static constexpr auto VTABLE{ VTABLE::IMemoryStoreBase };
+
+		virtual ~IMemoryStoreBase() = default;  // 00
+
+		// add
+		virtual std::size_t Size(void const* a_mem) const = 0;                 // 01
+		virtual void        GetMemoryStats(MemoryStats* a_stats) = 0;          // 02
+		virtual bool        ContainsBlockImpl(const void* a_block) const = 0;  // 03
+	};
+	static_assert(sizeof(IMemoryStoreBase) == 0x8);
+}
@@ -0,0 +1,212 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSInputEventUser.h"
+#include "RE/B/BSTAtomicValue.h"
+#include "RE/B/ButtonEvent.h"
+#include "RE/N/NiRect.h"
+#include "RE/S/SWFToCodeFunctionHandler.h"
+#include "RE/U/UIMessage.h"
+#include "RE/U/UI_DEPTH_PRIORITY.h"
+#include "RE/U/UI_MENU_FLAGS.h"
+#include "RE/U/UI_MESSAGE_RESULTS.h"
+#include "RE/U/UI_MESSAGE_TYPE.h"
+#include "RE/U/UserEvents.h"
+#include "Scaleform/M/MemoryHeap.h"
+#include "Scaleform/P/Ptr.h"
+#include "Scaleform/T/ThreadId.h"
+
+namespace RE
+{
+	enum class MENU_RENDER_CONTEXT;
+
+	class IMenu :
+		public SWFToCodeFunctionHandler,  // 00
+		public BSInputEventUser           // 10
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMenu };
+		static constexpr auto VTABLE{ VTABLE::IMenu };
+
+		using SWFToCodeFunctionHandler::operator new;
+		using SWFToCodeFunctionHandler::operator delete;
+
+		// NOLINTNEXTLINE(modernize-use-override)
+		virtual ~IMenu()  // 00
+		{
+			if (uiMovie) {
+				const auto id = Scaleform::GetCurrentThreadId();
+				uiMovie->SetCaptureThread(id);
+
+				const auto heap = uiMovie->GetHeap();
+				if (heap) {
+					heap->AssignToCurrentThread();
+				}
+			}
+		}
+
+		// override (BSInputEventUser)
+		bool ShouldHandleEvent(const InputEvent* a_event) override  // 01
+		{
+			using func_t = decltype(&IMenu::ShouldHandleEvent);
+			static REL::Relocation<func_t> func{ ID::IMenu::ShouldHandleEvent };
+			return func(this, a_event);
+		}
+
+		void OnButtonEvent(const ButtonEvent* a_event) override  // 08
+		{
+			if (menuObj.IsObject()) {
+				auto strUserEvent = a_event->QUserEvent();
+				if (a_event->disabled && CanHandleWhenDisabled(a_event)) {
+					strUserEvent = a_event->QRawUserEvent();
+				}
+
+				if (inputEventHandlingEnabled && menuObj.HasMember("ProcessUserEvent")) {
+					Scaleform::GFx::Value args[2];
+					args[0] = strUserEvent.c_str();
+					args[1] = a_event->QJustPressed();
+					menuObj.Invoke("ProcessUserEvent", nullptr, args, 2);
+				}
+			}
+		}
+
+		// add
+		virtual UI_MESSAGE_RESULTS ProcessMessage(UIMessage& a_message)  // 03
+		{
+			switch (*a_message.type) {
+				case UI_MESSAGE_TYPE::kShow:
+				case UI_MESSAGE_TYPE::kHide:
+					return UI_MESSAGE_RESULTS::kHandled;
+				case UI_MESSAGE_TYPE::kScaleformEvent:
+					return ProcessScaleformEvent(uiMovie.get(), a_message.QData());
+				case UI_MESSAGE_TYPE::kUpdateController:
+					RefreshPlatform();
+					return UI_MESSAGE_RESULTS::kPassOn;
+				default:
+					return UI_MESSAGE_RESULTS::kPassOn;
+			}
+		}
+
+		virtual void AdvanceMovie(float a_timeDelta, [[maybe_unused]] std::uint64_t a_time)  // 04
+		{
+			if (uiMovie) {
+				DoAdvanceMovie(a_timeDelta);
+				hasDoneFirstAdvanceMovie = true;
+			}
+		}
+
+		virtual void PreDisplay() { return; }   // 05
+		virtual void PostDisplay() { return; }  // 06
+
+		virtual bool PassesRenderConditionText(MENU_RENDER_CONTEXT a_reason, const BSFixedString& a_customRendererName) const  // 07
+		{
+			using func_t = decltype(&IMenu::PassesRenderConditionText);
+			static REL::Relocation<func_t> func{ ID::IMenu::PassesRenderConditionText };
+			return func(this, a_reason, a_customRendererName);
+		}
+
+		virtual void SetIsTopButtonBar([[maybe_unused]] bool a_isTopButtonBar) { return; }  // 08
+
+		virtual void OnMenuStackChanged(const BSFixedString& a_topMenuName, bool a_passesTopMenuTest)  // 09
+		{
+			const bool topMenuTest = a_passesTopMenuTest || (a_topMenuName == "PauseMenu"sv && RendersUnderPauseMenu());
+			if (passesTopMenuTest != topMenuTest) {
+				passesTopMenuTest = topMenuTest;
+				OnMenuDisplayStateChanged();
+			}
+		}
+
+		virtual void OnMenuDisplayStateChanged() { return; }  // 0A
+
+		virtual void OnAddedToMenuStack()  // 0B
+		{
+			menuFlags.set(UI_MENU_FLAGS::kOnStack);
+			OnMenuDisplayStateChanged();
+		}
+
+		virtual void OnRemovedFromMenuStack()  // 0C
+		{
+			menuFlags.reset(UI_MENU_FLAGS::kOnStack);
+			OnMenuDisplayStateChanged();
+		}
+
+		virtual bool CanAdvanceMovie(bool a_pauseMenuShowing)  // 0D
+		{
+			return !a_pauseMenuShowing || depthPriority > UI_DEPTH_PRIORITY::kGameMessage || AdvancesUnderPauseMenu();
+		}
+
+		virtual bool CanHandleWhenDisabled([[maybe_unused]] const ButtonEvent* a_event) { return false; }                      // 0E
+		virtual bool OnButtonEventRelease([[maybe_unused]] const BSFixedString& a_eventName) { return false; }                 // 0F
+		virtual bool CacheShaderFXQuadsForRenderer_Impl() { return false; }                                                    // 10
+		virtual void TransferCachedShaderFXQuadsForRenderer([[maybe_unused]] const BSFixedString& a_rendererName) { return; }  // 11
+		virtual void SetViewportRect([[maybe_unused]] const NiRect<float>& a_viewportRect) { return; }                         // 12
+
+		[[nodiscard]] bool AdvancesUnderPauseMenu() const noexcept { return menuFlags.all(UI_MENU_FLAGS::kAdvancesUnderPauseMenu); }
+		[[nodiscard]] bool AssignsCursorToRenderer() const noexcept { return menuFlags.all(UI_MENU_FLAGS::kAssignCursorToRenderer); }
+
+		void DoAdvanceMovie(float a_timeDelta)
+		{
+			++advanceWithoutRenderCount;
+			uiMovie->Advance(a_timeDelta);
+		}
+
+		void OnSetSafeRect()
+		{
+			using func_t = decltype(&IMenu::OnSetSafeRect);
+			static REL::Relocation<func_t> func{ ID::IMenu::OnSetSafeRect };
+			return func(this);
+		}
+
+		[[nodiscard]] bool OnStack() const noexcept { return menuFlags.all(UI_MENU_FLAGS::kOnStack); }
+
+		UI_MESSAGE_RESULTS ProcessScaleformEvent(Scaleform::GFx::Movie* a_movie, const IUIMessageData* a_data)
+		{
+			using func_t = decltype(&IMenu::ProcessScaleformEvent);
+			static REL::Relocation<func_t> func{ ID::IMenu::ProcessScaleformEvent };
+			return func(this, a_movie, a_data);
+		}
+
+		void RefreshPlatform()
+		{
+			using func_t = decltype(&IMenu::RefreshPlatform);
+			static REL::Relocation<func_t> func{ ID::IMenu::RefreshPlatform };
+			return func(this);
+		}
+
+		[[nodiscard]] bool RendersUnderPauseMenu() const noexcept { return menuFlags.all(UI_MENU_FLAGS::kRendersUnderPauseMenu); }
+
+		[[nodiscard]] constexpr bool IsMenuDisplayEnabled() const noexcept { return passesTopMenuTest && menuCanBeVisible; }
+
+		void SetMenuCodeObject(Scaleform::GFx::Movie& a_movie, std::string_view a_menuObjPath)
+		{
+			a_movie.GetVariable(std::addressof(menuObj), a_menuObjPath.data());
+			RegisterCodeObject(a_movie, menuObj);
+		}
+
+		void UpdateFlag(UI_MENU_FLAGS a_flag, bool a_set) noexcept
+		{
+			if (a_set) {
+				menuFlags.set(a_flag);
+			} else {
+				menuFlags.reset(a_flag);
+			}
+		}
+
+		[[nodiscard]] bool UsesCursor() const noexcept { return menuFlags.all(UI_MENU_FLAGS::kUsesCursor); }
+
+		// members
+		Scaleform::GFx::Value                                     menuObj;                                              // 20
+		Scaleform::Ptr<Scaleform::GFx::Movie>                     uiMovie;                                              // 40
+		BSFixedString                                             customRendererName;                                   // 48
+		BSFixedString                                             menuName;                                             // 50
+		REX::TEnumSet<UI_MENU_FLAGS, std::uint32_t>               menuFlags;                                            // 58
+		BSTAtomicValue<std::uint32_t>                             advanceWithoutRenderCount{ 0 };                       // 5C
+		bool                                                      passesTopMenuTest{ true };                            // 60
+		bool                                                      menuCanBeVisible{ true };                             // 61
+		bool                                                      hasQuadsForCumstomRenderer{ false };                  // 62
+		bool                                                      hasDoneFirstAdvanceMovie{ false };                    // 63
+		UI_DEPTH_PRIORITY                                         depthPriority{ UI_DEPTH_PRIORITY::kStandard };        // 64
+		REX::TEnumSet<UserEvents::INPUT_CONTEXT_ID, std::int32_t> inputContext{ UserEvents::INPUT_CONTEXT_ID::kNone };  // 68
+	};
+	static_assert(sizeof(IMenu) == 0x70);
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSIntrusiveRefCounted.h"
+
+namespace RE
+{
+	class alignas(0x10) IMessageBoxCallback :
+		public BSIntrusiveRefCounted  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMessageBoxCallback };
+		static constexpr auto VTABLE{ VTABLE::IMessageBoxCallback };
+
+		virtual ~IMessageBoxCallback() = default;  // 00
+
+		// add
+		virtual void operator()(std::uint8_t a_buttonIdx) = 0;  // 01
+	};
+	static_assert(sizeof(IMessageBoxCallback) == 0x10);
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	class __declspec(novtable) IMovementInterface
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMovementInterface };
+		static constexpr auto VTABLE{ VTABLE::IMovementInterface };
+
+		virtual ~IMovementInterface() = default;  // 00
+	};
+	static_assert(sizeof(IMovementInterface) == 0x8);
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/I/IMovementInterface.h"
+
+namespace RE
+{
+	class PlayerControlsMovementData;
+
+	class __declspec(novtable) IMovementPlayerControls :
+		public IMovementInterface  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMovementPlayerControls };
+		static constexpr auto VTABLE{ VTABLE::IMovementPlayerControls };
+
+		// add
+		virtual void GetControllerOutput(std::uint32_t a_numericID, PlayerControlsMovementData& a_normalizedOutputData) = 0;  // 01
+	};
+	static_assert(sizeof(IMovementPlayerControls) == 0x8);
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/I/IMovementInterface.h"
+
+namespace RE
+{
+	class MovementData;
+
+	class __declspec(novtable) IMovementPlayerControlsFilter :
+		public IMovementInterface  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMovementPlayerControlsFilter };
+		static constexpr auto VTABLE{ VTABLE::IMovementPlayerControlsFilter };
+
+		// add
+		virtual void  FilterControllerOutput(const MovementData& a_previousFrameData, MovementData& a_inOutData, float a_timeDelta) const = 0;  // 01
+		virtual bool  ShouldPlayLargeDeltas() const = 0;                                                                                        // 02
+		virtual bool  IsInCombatStance() const = 0;                                                                                             // 03
+		virtual bool  DampenRotationInput() const = 0;                                                                                          // 04
+		virtual bool  DampenInput(float& a_acceleration, float& a_deceleration) const = 0;                                                      // 05
+		virtual bool  IsInThirdPerson() const = 0;                                                                                              // 06
+		virtual void  FilterDampenedOutput(const MovementData&, MovementData& a_inOutData) const = 0;                                           // 07
+		virtual bool  ForceWalkBeforeRun() const = 0;                                                                                           // 08
+		virtual float GetNormalizedAngleAccelerationMultiplier() const = 0;                                                                     // 09
+	};
+	static_assert(sizeof(IMovementPlayerControlsFilter) == 0x8);
+}
@@ -0,0 +1,67 @@
+#pragma once
+
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/I/IMovementInterface.h"
+#include "RE/M/Movement.h"
+
+namespace RE
+{
+	class BSPathingLocation;
+	class BSPathingRequest;
+	class IMovementParameters;
+	class NiPoint3;
+
+	class __declspec(novtable) IMovementState :
+		public IMovementInterface  // 0
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IMovementState };
+		static constexpr auto VTABLE{ VTABLE::IMovementState };
+
+		enum class CHARACTER_STATE
+		{
+			kOnGround = 0x0,
+			kJumping = 0x1,
+			kInAir = 0x2,
+			kClimbing = 0x3,
+			kFlying = 0x4,
+			kSwimming = 0x5,
+			kFloating = 0x6
+		};
+
+		// add
+		virtual std::uint32_t              DoGetNumericID() const = 0;                                                                     // 01
+		virtual void                       DoGetPathingLocation(BSPathingLocation& a_retLocation) const = 0;                               // 02
+		virtual void                       DoGetLocation(NiPoint3& a_retLocation) const = 0;                                               // 03
+		virtual void                       DoGetEulerAngles(NiPoint3& a_retAngles) const = 0;                                              // 04
+		virtual float                      DoGetMovementSpeed() const = 0;                                                                 // 05
+		virtual float                      DoGetAnimationSpeed() const = 0;                                                                // 06
+		virtual float                      DoGetCurrentSpeed() const = 0;                                                                  // 07
+		virtual void                       DoGetRotationSpeed(NiPoint3& a_outRotationSpeed) const = 0;                                     // 08
+		virtual void                       DoGetMovementRotation(NiPoint3& a_retMovementRotation) const = 0;                               // 09
+		virtual bool                       DoGetCurrentMaxSpeeds(Movement::MaxSpeeds& a_retMaxSpeeds) const = 0;                           // 0A
+		virtual float                      DoGetMovementRadius() const = 0;                                                                // 0B
+		virtual float                      DoGetMovementWidth() const = 0;                                                                 // 0C
+		virtual float                      DoGetMovementLength() const = 0;                                                                // 0D
+		virtual float                      DoGetMovementHeight() const = 0;                                                                // 0E
+		virtual float                      DoGetMovementPitch() const = 0;                                                                 // 0F
+		virtual float                      DoGetLookingHeight() const = 0;                                                                 // 10
+		virtual float                      DoGetPathingRadius() const = 0;                                                                 // 11
+		virtual bool                       DoMakeDefaultMovementParameters(BSTSmartPointer<IMovementParameters>& a_parameters) const = 0;  // 12
+		virtual const IMovementParameters& DoGetDefaultMovementParameters() const = 0;                                                     // 13
+		virtual float                      DoGetFlightAngleGain() const = 0;                                                               // 14
+		virtual CHARACTER_STATE            DoGetCharacterState() const = 0;                                                                // 15
+		virtual bool                       DoGetUseVelocityObstacles() const = 0;                                                          // 16
+		virtual std::uint32_t              DoGetCollisionFilter() const = 0;                                                               // 17
+		virtual bool                       DoCanRotate() const = 0;                                                                        // 18
+		virtual bool                       DoUpdatePathingRequest(const BSTSmartPointer<BSPathingRequest>& a_request) const = 0;           // 19
+		virtual void                       DoGetFaceTargetSource(NiPoint3& a_location, NiPoint3& a_orientation) const = 0;                 // 1A
+		virtual bool                       DoGetFaceTargetAllowRoll() const = 0;                                                           // 1B
+		virtual bool                       DoShouldDecelerateToStop(float a_currentSpeed, float& a_nonDecelerateStopDistance) const = 0;   // 1C
+		virtual void                       DoGetMaxAngles(NiPoint3& a_maxAngles) const = 0;                                                // 1D
+		virtual void                       DoGetLookingLocation(NiPoint3& a_location) const = 0;                                           // 1E
+		virtual bool                       DoGetSprinting() const = 0;                                                                     // 1F
+		virtual bool                       DoIsHovering() const = 0;                                                                       // 20
+	};
+	static_assert(sizeof(IMovementState) == 0x8);
+}
@@ -0,0 +1,20 @@
+#pragma once
+
+namespace RE
+{
+	enum class INPUT_DEVICE : std::int32_t
+	{
+		kNone = static_cast<std::underlying_type_t<INPUT_DEVICE>>(-1),
+
+		kKeyboard = 0,
+		kMouse,
+		kGamepad,
+
+		kSupported,
+
+		kKinect = 3,
+		kVirtualKeyboard,
+
+		kTotal
+	};
+}
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class INPUT_DEVICE_LIGHT_STATE : std::int32_t
+	{
+		kDeviceLightStatePowerArmorLight = 0x0,
+		kDeviceLightStatePowerArmor = 0x1,
+		kDeviceLightStatePipboyLight = 0x2,
+	};
+}
@@ -0,0 +1,16 @@
+#pragma once
+
+namespace RE
+{
+	enum class INPUT_EVENT_TYPE : std::int32_t
+	{
+		kButton = 0x0,
+		kMouseMove = 0x1,
+		kCursorMove = 0x2,
+		kChar = 0x3,
+		kThumbstick = 0x4,
+		kDeviceConnect = 0x5,
+		kKinect = 0x6,
+		kNone = 0x7
+	};
+}
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTTuple.h"
+
+namespace RE
+{
+	class INSTANCE_FILTER
+	{
+	public:
+		// members
+		std::uint32_t                                      levelOverride;     // 00
+		std::uint8_t                                       tierStartLevel;    // 04
+		std::uint8_t                                       altLevelsPerTier;  // 05
+		bool                                               epic;              // 06
+		BSScrapArray<BSTTuple<BGSKeyword*, std::uint32_t>> keywordChances;    // 08
+	};
+	static_assert(sizeof(INSTANCE_FILTER) == 0x28);
+}
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	enum class INTERACTING_STATE : std::int32_t
+	{
+		kNotInteracting = 0x0,
+		kWaitingToInteract = 0x1,
+		kInteracting = 0x2,
+		kWaitingToStopInteracting = 0x3
+	};
+}
@@ -0,0 +1,11 @@
+#pragma once
+
+namespace RE
+{
+	enum class INTERACTION_EXIT : std::int32_t
+	{
+		kNormal = 0x0,
+		kQuick = 0x1,
+		kInstant = 0x2
+	};
+}
@@ -0,0 +1,41 @@
+#pragma once
+
+#include "RE/B/BGSDirectionalAmbientLightingColors.h"
+
+namespace RE
+{
+	class INTERIOR_DATA
+	{
+	public:
+		// members
+		std::uint32_t                       ambient;                           // 00
+		std::uint32_t                       directional;                       // 04
+		std::uint32_t                       fogColorNear;                      // 08
+		float                               fogNear;                           // 0C
+		float                               fogFar;                            // 10
+		std::uint32_t                       directionalXY;                     // 14
+		std::uint32_t                       directionalZ;                      // 18
+		float                               directionalFade;                   // 1C
+		float                               clipDist;                          // 20
+		float                               fogPower;                          // 24
+		BGSDirectionalAmbientLightingColors directionalAmbientLightingColors;  // 28
+		std::uint32_t                       fogColorFar;                       // 48
+		float                               fogClamp;                          // 4C
+		float                               lightFadeStart;                    // 50
+		float                               lightFadeEnd;                      // 54
+		std::uint32_t                       lightingTemplateInheritanceFlags;  // 58
+		float                               fogHeightMid;                      // 5C
+		float                               fogHeightRange;                    // 60
+		std::uint32_t                       fogColorHighNear;                  // 64
+		std::uint32_t                       fogColorHighFar;                   // 68
+		float                               fogHighDensityScale;               // 6C
+		float                               fogNearColorScale;                 // 70
+		float                               fogFarColorScale;                  // 74
+		float                               fogHighNearColorScale;             // 78
+		float                               fogHighFarColorScale;              // 7C
+		float                               fogFarHeightMid;                   // 80
+		float                               fogFarHeightRange;                 // 84
+		std::uint32_t                       interiorOffset;                    // 88
+	};
+	static_assert(sizeof(INTERIOR_DATA) == 0x8C);
+}
@@ -0,0 +1,32 @@
+#pragma once
+
+namespace RE
+{
+	class BSPathingStreamRead;
+	class BSPathingStreamWrite;
+	class ICheckEndReachedFunctorMapper;
+	class MovementPlannerAgentReturnDataSmallDelta;
+	class MovementTweenerAgentOutputData;
+	class PathFollowerStateUpdateData;
+
+	class IPathFollowerState
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IPathFollowerState };
+		static constexpr auto VTABLE{ VTABLE::IPathFollowerState };
+
+		enum class PATH_FOLLOWER_STATE_RESULT : std::uint32_t
+		{
+			kContinue = 0x0,
+			kDone = 0x1
+		};
+
+		virtual ~IPathFollowerState();  // 00
+
+		// add
+		virtual IPathFollowerState::PATH_FOLLOWER_STATE_RESULT Update(const PathFollowerStateUpdateData*, MovementPlannerAgentReturnDataSmallDelta*, MovementTweenerAgentOutputData*);  // 01
+		virtual void                                           SaveGame(BSPathingStreamWrite*, const ICheckEndReachedFunctorMapper*) = 0;                                               // 02
+		virtual void                                           LoadGame(BSPathingStreamRead*, const ICheckEndReachedFunctorMapper*) = 0;                                                // 03
+	};
+	static_assert(sizeof(IPathFollowerState) == 0x8);
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+namespace RE
+{
+	class IPipboyThrottledValue
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IPipboyThrottledValue };
+		static constexpr auto VTABLE{ VTABLE::IPipboyThrottledValue };
+
+		// members
+		virtual ~IPipboyThrottledValue();  // 00
+
+		// add
+		void* Update();  // 01
+	};
+	static_assert(sizeof(IPipboyThrottledValue) == 0x8);
+}
@@ -0,0 +1,17 @@
+#pragma once
+
+namespace RE
+{
+	class __declspec(novtable) IPostAnimationChannelUpdateFunctor
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IPostAnimationChannelUpdateFunctor };
+		static constexpr auto VTABLE{ VTABLE::IPostAnimationChannelUpdateFunctor };
+
+		virtual ~IPostAnimationChannelUpdateFunctor() = default;  // 00
+
+		// add
+		virtual void DoPostAnimationChannelUpdate() = 0;  // 01
+	};
+	static_assert(sizeof(IPostAnimationChannelUpdateFunctor) == 0x8);
+}
@@ -0,0 +1,89 @@
+#pragma once
+
+namespace RE
+{
+	class BSDynamicLines;
+	class BSDynamicTriShape;
+	class BSLines;
+	class BSMeshLODTriShape;
+	class BSMultiStreamInstanceTriShape;
+	class BSSubIndexTriShape;
+	class BSTriShape;
+	class FadeNodeSettings;
+	class NiAVObject;
+	class NiColorA;
+	class NiDefaultAVObjectPalette;
+	class NiNode;
+	class NiPick;
+	class NiPoint2;
+	class NiPoint3;
+	class NiShadeProperty;
+	class NiStream;
+	class NiTexture;
+
+	namespace BSGraphics
+	{
+		class Texture;
+	}
+
+	class __declspec(novtable) IRendererResourceManager
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IRendererResourceManager };
+		static constexpr auto VTABLE{ VTABLE::IRendererResourceManager };
+
+		virtual ~IRendererResourceManager();
+
+		virtual BSTriShape*         CreateTriShape(std::uint32_t a_numTriangles, std::uint16_t* a_indices, std::uint32_t a_numVertices, NiPoint3* a_positions, NiPoint2* a_texCoords0, NiColorA* a_texCoords1, NiPoint3* a_normals, NiPoint3* a_binormals, NiPoint3* a_tangents, NiColorA* a_colors, NiColorA* a_skinBoneWeights, std::uint8_t* a_skinBoneIndices, NiColorA* a_landscapeData1, NiColorA* a_landscapeData2, float* a_eyeData, bool a_generatePositionData) = 0;
+		virtual BSTriShape*         CreateTriShape(std::uint32_t a_numTriangles, std::uint32_t a_numVertices, NiPoint3* a_positions, NiPoint2* a_texCoords, NiColorA* a_colors, std::uint16_t* a_indices) = 0;
+		virtual void*               CreateTriShape(NiStream* a_stream, std::uint64_t a_vertexDesc, std::uint32_t a_vertexCount, std::uint32_t a_indexCount, char** a_dynamicData) = 0;
+		virtual void*               CreateTriShapeRendererData(void* a_vertexBuffer, std::uint64_t a_vertexDesc, std::uint16_t* a_indices, std::uint32_t a_indexCount) = 0;
+		virtual BSSubIndexTriShape* CreateSubIndexTriShape(std::uint32_t a_numTriangles, std::uint32_t a_numSegments, std::uint16_t* a_indices, std::uint32_t a_numVertices, NiPoint3* a_positions, NiPoint2* a_texCoords0, NiColorA* a_texCoords1, NiPoint3* a_normals, NiPoint3* a_binormals, NiPoint3* a_tangents, NiColorA* a_colors, NiColorA* a_skinBoneWeights, std::uint8_t* a_skinBoneIndices, NiColorA* a_landscapeData1, NiColorA* a_landscapeData2, float* a_eyeData) = 0;
+		virtual void                IncRefTriShape(void* a_rendererData) = 0;
+		virtual void                DecRefTriShape(void* a_rendererData) = 0;
+		virtual BSDynamicTriShape*  CreateDynamicTriShape(std::uint32_t a_dynamicFlags, std::uint32_t a_numTriangles, std::uint16_t* a_indices, std::uint32_t a_numVertices, NiPoint3* a_positions, NiPoint2* a_texCoords0, NiColorA* a_texCoords1, NiPoint3* a_normals, NiPoint3* a_binormals, NiPoint3* a_tangents, NiColorA* a_colors, NiColorA* a_skinBoneWeights, std::uint8_t* a_skinBoneIndices, NiColorA* a_landscapeData1, NiColorA* a_landscapeData2, float* a_eyeData) = 0;
+		virtual BSDynamicTriShape*  CreateDynamicTriShape(std::uint32_t, std::uint32_t, std::uint32_t, NiPoint3*, NiPoint2*, NiColorA*, std::uint16_t*) = 0;
+		virtual void                IncRefDynamicTriShape(void* a_rendererData) = 0;
+		virtual void                DecRefDynamicTriShape(void* a_rendererData) = 0;
+		virtual void                ConvertBSTriShapeToBSDynamicTriShape(NiNode* a_root, NiDefaultAVObjectPalette* a_objectPalette) = 0;
+		virtual void                ApplyMaterials(NiAVObject* a_root) = 0;
+		virtual void                SetTriShapeStreamDynamicFlags(std::uint32_t) = 0;
+		virtual void*               CreateParticleShape() = 0;
+		virtual void                IncRefParticleShape(void* a_rendererData) = 0;
+		virtual void                DecRefParticleShape(void* a_rendererData) = 0;
+		virtual BSLines*            CreateLineShape(std::uint32_t, std::uint16_t*, std::uint32_t, NiPoint3*, NiPoint2*, NiColorA*, NiPoint3*, NiPoint3*, NiPoint3*, NiColorA*, NiColorA*, std::uint8_t*, NiColorA*, NiColorA*, float*) = 0;
+		virtual BSDynamicLines*     CreateDynamicLineShape(std::uint32_t, std::uint32_t, std::uint32_t, NiPoint3*, NiPoint2*, NiColorA*, std::uint16_t*) = 0;
+		virtual void*               CreateDynamicLineShape(NiStream*, std::uint64_t, std::uint32_t, std::uint32_t) = 0;
+		virtual BSDynamicLines*     CreateDynamicLineShape(std::uint32_t, std::uint32_t, std::uint16_t*, std::uint32_t, NiPoint3*, NiPoint2*, NiColorA*, NiPoint3*, NiPoint3*, NiPoint3*, NiColorA*, NiColorA*, std::uint8_t*, NiColorA*, NiColorA*, float*) = 0;
+		virtual void                IncRefLines(void* a_rendererData) = 0;
+		virtual void                DecRefLines(void* a_rendererData) = 0;
+		virtual void                IncRefDynamicLines(void* a_rendererData) = 0;
+		virtual void                DecRefDynamicLines(void* a_rendererData) = 0;
+		virtual void                LoadTexture(NiTexture* apTexture) = 0;
+		virtual void                CreateStreamingTexture(NiTexture* a_texture, const void* a_userDataIn, void* a_userDataOut) = 0;
+		virtual bool                ReadStreamingTextureData(NiTexture* a_texture, void* a_userDataIn) = 0;
+		virtual bool                CreateStreamingTextureArraySlice(NiTexture* a_texture, const void* a_userDataIn, void* a_userDataOut, std::uint32_t a_slice) = 0;
+		virtual bool                ReadStreamingTextureDataToArraySlice(NiTexture* a_texture, void* a_userDataIn, std::uint32_t a_slice) = 0;
+		virtual void                FinishStreamingTexture(NiTexture* a_texture) = 0;
+		virtual void                IncRefTexture(BSGraphics::Texture* a_rendererData) = 0;
+		virtual void                DecRefTexture(BSGraphics::Texture* a_rendererData) = 0;
+		virtual void                GetTextureWidthHeight(NiTexture* a_texture, std::uint32_t* a_width, std::uint32_t* a_height) = 0;
+		virtual std::uint32_t       GetTextureFormat(NiTexture* a_texture) = 0;
+		virtual bool                UpdateTextureToDesiredMipLevel(NiTexture* a_texture, std::uint32_t*) = 0;
+		virtual void                LoadUpgradeTextureData(NiTexture* a_texture) = 0;
+		virtual bool                UpdateStreamingTextureToDesiredMipLevel(NiTexture* a_texture, std::uint32_t*, void*, void*) = 0;
+		virtual void                FinishStreamingTextureUpgade(NiTexture* a_texture) = 0;
+		virtual void*               CreateVertexBuffer(std::uint32_t* a_dataSize, void* a_data, std::uint32_t a_stride, std::uint64_t) = 0;
+		virtual void                DecRefVertexBuffer(void* a_rendererData) = 0;
+		virtual NiShadeProperty*    CreateDefaultEffectShaderProperty(bool a_vertexColors, bool a_skinned) = 0;
+		virtual BSMeshLODTriShape*  CreateMeshLODTriShape(std::uint32_t*, std::uint32_t, std::uint64_t, std::uint32_t, std::uint32_t, void*) = 0;
+		virtual BSMeshLODTriShape*  CreateMeshLODTriShape(BSTriShape*, std::uint32_t*, std::uint32_t) = 0;
+		virtual std::uint32_t       UpdateIndexBufferForInstancing(BSMultiStreamInstanceTriShape*, std::uint32_t) = 0;
+		virtual bool                FindIntersectionsTriShapeFastPath(const NiPoint3*, const NiPoint3*, NiPick*, BSTriShape*) = 0;
+		virtual void                CreateTangentSpace(std::uint32_t, std::uint16_t*, std::uint32_t, NiPoint3*, NiPoint2*, NiPoint3*, NiPoint3*, NiPoint3*) = 0;
+		virtual float               GetShaderFrameCount() = 0;
+		virtual float               GetShaderTimerDelta() = 0;
+		virtual void                GetFadeNodeSettings(FadeNodeSettings* a_skinned) = 0;
+		virtual void                GetCameraVectors(NiPoint3* a_up, NiPoint3* a_right, NiPoint3* a_direction) = 0;
+	};
+}
@@ -0,0 +1,25 @@
+#pragma once
+
+namespace RE
+{
+	enum class ITEM_CHANGE_FILTER : std::uint32_t
+	{
+		kNone = 0x0,
+		kFavorites = 0x1,
+		kWeapons = 0x2,
+		kApparel = 0x4,
+		kAid = 0x8,
+		kScrolls = 0x10,
+		kFood = 0x20,
+		kIngredients = 0x40,
+		kBooks = 0x80,
+		kKeys = 0x100,
+		kMisc = 0x200,
+		kJunk = 0x400,
+		kMods = 0x800,
+		kAmmo = 0x1000,
+		kHolotapes = 0x2000,
+		kTotal = 0xE,
+		kAll = 0x3FFF
+	};
+}
@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	enum class ITEM_REMOVE_REASON : std::int32_t
+	{
+		kNone = 0x0,
+		kStealing = 0x1,
+		kSelling = 0x2,
+		KDropping = 0x3,
+		kStoreContainer = 0x4,
+		kStoreTeammate = 0x5
+	};
+}
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/U/UIMessage.h"
+
+namespace RE
+{
+	class __declspec(novtable) IUIMessageData :
+		public UIMessage  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IUIMessageData };
+		static constexpr auto VTABLE{ VTABLE::IUIMessageData };
+
+		// override (UIMessage)
+		IUIMessageData*       QData() override { return this; }        // 02
+		const IUIMessageData* QData() const override { return this; }  // 01
+	};
+	static_assert(sizeof(IUIMessageData) == 0x18);
+}
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace RE
+{
+	class IdleInputEvent
+	{
+	public:
+		// members
+		bool starting;  // 00
+	};
+	static_assert(sizeof(IdleInputEvent) == 0x1);
+}
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class IdleMovementData
+	{
+	public:
+		// members
+		NiPoint3A translation;                    // 00
+		NiPoint3A rotation;                       // 10
+		NiPoint3A startVelocity;                  // 20
+		NiPoint3A endVelocity;                    // 30
+		NiPoint3A startRotSpeed;                  // 40
+		NiPoint3A endRotSpeed;                    // 50
+		NiPoint3A averageRotSpeed;                // 60
+		NiPoint3A translationUntilAllowRotation;  // 70
+		NiPoint3A velocityAtAllowRotation;        // 80
+		NiPoint3A rotSpeedAtAllowRotation;        // 90
+		float     duration;                       // A0
+		float     tweenStart;                     // A4
+		float     tweenEnd;                       // A8
+		float     rotationTweenStart;             // AC
+		float     rotationTweenEnd;               // B0
+		float     syncAnimTimes[4];               // B4
+		bool      usesAllowRotation;              // C4
+	};
+	static_assert(sizeof(IdleMovementData) == 0xD0);
+}
@@ -0,0 +1,73 @@
+#pragma once
+
+namespace RE
+{
+	class ImageSpaceBaseData
+	{
+	public:
+		class HDR  // HNAM
+		{
+		public:
+			// members
+			float eyeAdaptSpeed;          // 00
+			float bloomBlurRadius;        // 04
+			float bloomThreshold;         // 08
+			float bloomScale;             // 0C
+			float receiveBloomThreshold;  // 10
+			float white;                  // 14
+			float sunlightScale;          // 18
+			float skyScale;               // 1C
+			float eyeAdaptStrength;       // 20
+		};
+		static_assert(sizeof(HDR) == 0x24);
+
+		class Cinematic  // CNAM
+		{
+		public:
+			// members
+			float saturation;  // 0
+			float brightness;  // 4
+			float contrast;    // 8
+		};
+		static_assert(sizeof(Cinematic) == 0xC);
+
+		class Tint  // TNAM
+		{
+		public:
+			class ColorF
+			{
+			public:
+				// members
+				float red;    // 0
+				float green;  // 4
+				float blue;   // 8
+			};
+			static_assert(sizeof(ColorF) == 0xC);
+
+			// members
+			float  amount;  // 00
+			ColorF color;   // 04
+		};
+		static_assert(sizeof(Tint) == 0x10);
+
+		class DepthOfField  // DNAM
+		{
+		public:
+			// members
+			float strength;          // 00
+			float distance;          // 04
+			float range;             // 08
+			float vignetteRadius;    // 0C
+			float vignetteStrength;  // 10
+			float mode;              // 14
+		};
+		static_assert(sizeof(DepthOfField) == 0x18);
+
+		// members
+		HDR          hdrData;        // 00
+		Cinematic    cinematicData;  // 24
+		Tint         tintData;       // 30
+		DepthOfField dofData;        // 40
+	};
+	static_assert(sizeof(ImageSpaceBaseData) == 0x58);
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/I/ImageSpaceBaseData.h"
+#include "RE/I/ImageSpaceModData.h"
+
+namespace RE
+{
+	class ImageSpaceData
+	{
+	public:
+		// members
+		ImageSpaceBaseData baseData;           //00
+		ImageSpaceModData  modData;            //58
+		float              highestTintAmount;  //A8
+		float              highestFadeAmount;  //AC
+	};
+	static_assert(sizeof(ImageSpaceData) == 0xB0);
+}
@@ -0,0 +1,73 @@
+#pragma once
+
+#include "RE/N/NiTArray.h"
+
+namespace RE
+{
+	class BSTriShape;
+	class ImageSpaceManager;
+	class ImageSpaceEffectParam;
+	class ImageSpaceTexture;
+
+	namespace BSGraphics
+	{
+		enum class TextureFilterMode;
+	}
+
+	class __declspec(novtable) ImageSpaceEffect
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffect };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffect };
+
+		class EffectDesc
+		{
+		public:
+			// members
+			std::uint32_t     startEffect;   // 00
+			std::uint32_t     lastEffect;    // 04
+			ImageSpaceEffect* parentEffect;  // 08
+			std::uint64_t     labelWait;     // 10
+			std::uint64_t*    writeLabel;    // 18
+		};
+		static_assert(sizeof(EffectDesc) == 0x20);
+
+		class EffectInput
+		{
+		public:
+			// members
+			std::int32_t                  texIndex;    // 00
+			BSGraphics::TextureFilterMode filterMode;  // 04
+		};
+		static_assert(sizeof(EffectInput) == 0x08);
+
+		virtual ~ImageSpaceEffect();  // 00
+
+		// add
+		virtual void Render(BSTriShape* a_geometry, ImageSpaceEffectParam* a_param);                                                   // 01
+		virtual void Dispatch(ImageSpaceEffectParam* a_param, bool a_useAsyncPipe, std::uint32_t a_effect, EffectDesc* a_effectDesc);  // 02
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param);                                              // 03
+		virtual void Shutdown();                                                                                                       // 04
+		virtual void BorrowTextures(ImageSpaceEffectParam* a_param);                                                                   // 05
+		virtual void ReturnTextures();                                                                                                 // 06
+		virtual void UpdateComputeShaderParam(std::uint32_t a_effect);                                                                 // 07
+		virtual bool IsActive();                                                                                                       // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param);                                                                     // 09
+		virtual bool SetRenderStates(ImageSpaceEffectParam* a_param);                                                                  // 0A
+		virtual bool RestoreRenderStates(ImageSpaceEffectParam* a_param);                                                              // 0B
+
+		// members
+		bool                                      isActive;              // 08
+		bool                                      paramsChanged;         // 09
+		NiTPrimitiveArray<ImageSpaceEffect*>      effectList;            // 10
+		NiTPrimitiveArray<ImageSpaceEffectParam*> effectParamList;       // 28
+		NiTPrimitiveArray<ImageSpaceTexture*>     textures;              // 40
+		NiTPrimitiveArray<ImageSpaceTexture*>     vsTextures;            // 58
+		NiTPrimitiveArray<EffectInput*>           effectInputs;          // 70
+		NiTPrimitiveArray<std::int32_t*>          effectOutput;          // 88
+		bool                                      isComputeShader;       // A0
+		std::uint32_t                             nbOutput;              // A4
+		bool                                      useDynamicResolution;  // A8
+	};
+	static_assert(sizeof(ImageSpaceEffect) == 0xB0);
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffectOption.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectBokehDepthOfField :
+		public ImageSpaceEffectOption  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectBokehDepthOfField };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectBokehDepthOfField };
+
+		virtual ~ImageSpaceEffectBokehDepthOfField() override;  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Render(BSTriShape* a_geometry, ImageSpaceEffectParam* a_param) override;       // 01
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual bool IsActive() override;                                                           // 08
+	};
+	static_assert(sizeof(ImageSpaceEffectBokehDepthOfField) == 0xC8);
+}
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffectOption.h"
+#include "RE/I/ImageSpaceTexture.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectDepthOfField :
+		public ImageSpaceEffectOption  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectDepthOfField };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectDepthOfField };
+
+		virtual ~ImageSpaceEffectDepthOfField() override;  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual void BorrowTextures(ImageSpaceEffectParam* a_param) override;                       // 05
+		virtual void ReturnTextures() override;                                                     // 06
+		virtual bool IsActive() override;                                                           // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		// members
+		ImageSpaceTexture maskBuffer;  // B0
+		ImageSpaceTexture buffer[3];   // F0
+		bool              useFog;      // 168
+	};
+	static_assert(sizeof(ImageSpaceEffectDepthOfField) == 0x170);
+}
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+#include "RE/I/ImageSpaceTexture.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectFullScreenBlur :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectFullScreenBlur };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectFullScreenBlur };
+
+		virtual ~ImageSpaceEffectFullScreenBlur() override;  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Render(BSTriShape* a_geometry, ImageSpaceEffectParam* a_param) override;       // 01
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual void BorrowTextures(ImageSpaceEffectParam* a_param) override;                       // 05
+		virtual void ReturnTextures() override;                                                     // 06
+		virtual bool IsActive() override;                                                           // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		inline static bool* GetDisable()
+		{
+			static REL::Relocation<bool*> value{ ID::ImageSpaceEffectFullScreenBlur::Disable };
+			return value.get();
+		}
+
+		// members
+		ImageSpaceTexture buffer[3];  // B0
+	};
+	static_assert(sizeof(ImageSpaceEffectFullScreenBlur) == 0x128);
+}
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+#include "RE/I/ImageSpaceTexture.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectGetHit :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectGetHit };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectGetHit };
+
+		virtual ~ImageSpaceEffectGetHit();  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Render(BSTriShape* a_geometry, ImageSpaceEffectParam* a_param) override;       // 01
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual void BorrowTextures(ImageSpaceEffectParam* a_param) override;                       // 05
+		virtual void ReturnTextures() override;                                                     // 06
+		virtual bool IsActive() override;                                                           // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		inline static bool* GetDisable()
+		{
+			static REL::Relocation<bool*> value{ ID::ImageSpaceEffectGetHit::Disable };
+			return value.get();
+		}
+
+		// members
+		float*            data;       // B0
+		ImageSpaceTexture buffer[2];  // B8
+	};
+	static_assert(sizeof(ImageSpaceEffectGetHit) == 0x108);
+}
@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectHDR :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectHDR };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectHDR };
+
+		virtual ~ImageSpaceEffectHDR();  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Render(BSTriShape* a_geometry, ImageSpaceEffectParam* a_param) override;       // 01
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual void Shutdown() override;                                                           // 04
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		inline static bool* GetUsePipboyScreenMask()
+		{
+			static REL::Relocation<bool*> value{ ID::ImageSpaceEffectHDR::UsePipboyScreenMask };
+			return value.get();
+		}
+	};
+	static_assert(sizeof(ImageSpaceEffectHDR) == 0xB0);
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectMotionBlur :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectMotionBlur };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectMotionBlur };
+
+		virtual ~ImageSpaceEffectMotionBlur();  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual bool IsActive() override;                                                           // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+	};
+	static_assert(sizeof(ImageSpaceEffectMotionBlur) == 0xB0);
+}
@@ -0,0 +1,18 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectOption :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectOption };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectOption };
+
+		// members
+		NiTPrimitiveArray<bool> effectOn;  // B0
+	};
+	static_assert(sizeof(ImageSpaceEffectOption) == 0xC8);
+}
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class NiTexture;
+
+	class __declspec(novtable) ImageSpaceEffectPipboyScreen :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectPipboyScreen };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectPipboyScreen };
+
+		virtual ~ImageSpaceEffectPipboyScreen();  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual void ReturnTextures() override;                                                     // 06
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		inline static bool* GetPowerArmorPipboy()
+		{
+			static REL::Relocation<bool*> value{ ID::ImageSpaceEffectPipboyScreen::PowerArmorPipboy };
+			return value.get();
+		}
+
+		// members
+		NiPointer<NiTexture> scanlineTexture;  // B0
+		NiPointer<NiTexture> vScanTexture;     // B8
+	};
+	static_assert(sizeof(ImageSpaceEffectPipboyScreen) == 0xC0);
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectRadialBlur :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectRadialBlur };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectRadialBlur };
+
+		virtual ~ImageSpaceEffectRadialBlur();  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual bool IsActive() override;                                                           // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		inline static bool* GetDisable()
+		{
+			static REL::Relocation<bool*> value{ ID::ImageSpaceEffectRadialBlur::Disable };
+			return value.get();
+		}
+	};
+	static_assert(sizeof(ImageSpaceEffectRadialBlur) == 0xB0);
+}
@@ -0,0 +1,35 @@
+#pragma once
+
+#include "RE/I/ImageSpaceEffect.h"
+
+namespace RE
+{
+	class __declspec(novtable) ImageSpaceEffectTemporalAA :
+		public ImageSpaceEffect  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectTemporalAA };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectTemporalAA };
+
+		virtual ~ImageSpaceEffectTemporalAA();  // 00
+
+		// override (ImageSpaceEffect)
+		virtual void Render(BSTriShape* a_geometry, ImageSpaceEffectParam* a_param) override;       // 01
+		virtual void Setup(ImageSpaceManager* a_manager, ImageSpaceEffectParam* a_param) override;  // 03
+		virtual bool IsActive() override;                                                           // 08
+		virtual bool UpdateParams(ImageSpaceEffectParam* a_param) override;                         // 09
+
+		inline static std::uint32_t* GetMaskS()
+		{
+			static REL::Relocation<std::uint32_t*> value{ ID::ImageSpaceEffectTemporalAA::MaskS };
+			return value.get();
+		}
+
+		// members
+		float previousInvTexSizeX;         // B0
+		float previousInvTexSizeY;         // B4
+		float previousDynamicWidthRatio;   // B8
+		float previousDynamicHeightRatio;  // BC
+	};
+	static_assert(sizeof(ImageSpaceEffectTemporalAA) == 0xC0);
+}
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class NiTexture;
+
+	namespace BSGraphics
+	{
+		class Texture;
+	}
+
+	class ImageSpaceLUTData
+	{
+	public:
+		// members
+		BSFixedString        filename[4];   // 00
+		float                weight[4];     // 20
+		NiPointer<NiTexture> niTexture[4];  // 30
+		BSGraphics::Texture* texture[4];    // 50
+	};
+	static_assert(sizeof(ImageSpaceLUTData) == 0x70);
+}
@@ -0,0 +1,305 @@
+#pragma once
+
+#include "RE/I/ImageSpaceData.h"
+#include "RE/I/ImageSpaceLUTData.h"
+#include "RE/N/NiColor.h"
+#include "RE/N/NiPointer.h"
+#include "RE/N/NiRect.h"
+#include "RE/N/NiTArray.h"
+
+namespace RE
+{
+	class BSTriShape;
+	class ImageSpaceEffect;
+
+	class ImageSpaceManager
+	{
+	public:
+		enum class ImageSpaceEffectEnum
+		{
+			EFFECT_WORLD_CAMERA = 0,
+			EFFECT_TEMPORAL_AA_PRE_HDR = 1,
+			EFFECT_SUNBEAMS = 2,
+			EFFECT_HDR = 3,
+			EFFECT_HDR_CS = 4,
+			EFFECT_REFRACTION = 5,
+			EFFECT_DEPTH_OF_FIELD = 6,
+			EFFECT_DEPTH_OF_FIELD_SPLIT_SCREEN = 7,
+			EFFECT_RADIAL_BLUR = 8,
+			EFFECT_FULLSCREEN_BLUR = 9,
+			EFFECT_MOTIONBLUR = 10,
+			EFFECT_GETHIT = 11,
+			EFFECT_VATS_TARGET = 12,
+			EFFECT_FULLSCREEN_COLOR = 13,
+			EFFECT_SHADER_GAMMA_CORRECT = 14,
+			EFFECT_SHADER_GAMMA_CORRECT_LUT = 15,
+			EFFECT_SHADER_GAMMA_CORRECT_RESIZE = 16,
+			EFFECT_SHADER_FXAA = 17,
+			EFFECT_TEMPORAL_AA = 18,
+			EFFECT_TEMPORAL_OLD_AA = 19,
+			EFFECT_BOKEH_DEPTH_OF_FIELD = 20,
+			EFFECT_UPSAMPLE_DYNAMIC_RESOLUTION = 21,
+			EFFECT_ENDOFFRAME_END = 22,
+			EFFECT_MAP = EFFECT_ENDOFFRAME_END,
+			EFFECT_BLUR_START = 23,
+			EFFECT_BLUR3 = EFFECT_BLUR_START,
+			EFFECT_BLUR5 = 24,
+			EFFECT_BLUR7 = 25,
+			EFFECT_BLUR9 = 26,
+			EFFECT_BLUR11 = 27,
+			EFFECT_BLUR13 = 28,
+			EFFECT_BLUR15 = 29,
+			EFFECT_BLUR_END = EFFECT_BLUR15,
+			EFFECT_NONHDR_BLUR3 = 30,
+			EFFECT_NONHDR_BLUR5 = 31,
+			EFFECT_NONHDR_BLUR7 = 32,
+			EFFECT_NONHDR_BLUR9 = 33,
+			EFFECT_NONHDR_BLUR11 = 34,
+			EFFECT_NONHDR_BLUR13 = 35,
+			EFFECT_NONHDR_BLUR15 = 36,
+			EFFECT_BRIGHTPASS_BLUR3 = 37,
+			EFFECT_BRIGHTPASS_BLUR5 = 38,
+			EFFECT_BRIGHTPASS_BLUR7 = 39,
+			EFFECT_BRIGHTPASS_BLUR9 = 40,
+			EFFECT_BRIGHTPASS_BLUR11 = 41,
+			EFFECT_BRIGHTPASS_BLUR13 = 42,
+			EFFECT_BRIGHTPASS_BLUR15 = 43,
+			EFFECT_BRIGHTPASS_HDR_BLUR15_320x180CS = 44,
+			EFFECT_BRIGHTPASS_HDR_BLUR15_480x270CS = 45,
+			EFFECT_BRIGHTPASS_HDR_BLUR15_1024x1024CS = 46,
+			EFFECT_BLUR_CS_START = 47,
+			EFFECT_BLUR3_480x270CS = EFFECT_BLUR_CS_START,
+			EFFECT_BLUR5_480x270CS = 48,
+			EFFECT_BLUR7_480x270CS = 49,
+			EFFECT_BLUR9_480x270CS = 50,
+			EFFECT_BLUR11_480x270CS = 51,
+			EFFECT_BLUR13_480x270CS = 52,
+			EFFECT_BLUR15_480x270CS = 53,
+			EFFECT_BLUR_CS_END = EFFECT_BLUR15_480x270CS,
+			EFFECT_BRIGHTPASS_BLUR3_480x270CS = 54,
+			EFFECT_BRIGHTPASS_BLUR5_480x270CS = 55,
+			EFFECT_BRIGHTPASS_BLUR7_480x270CS = 56,
+			EFFECT_BRIGHTPASS_BLUR9_480x270CS = 57,
+			EFFECT_BRIGHTPASS_BLUR11_480x270CS = 58,
+			EFFECT_BRIGHTPASS_BLUR13_480x270CS = 59,
+			EFFECT_BRIGHTPASS_BLUR15_480x270CS = 60,
+			EFFECT_WATER_DISPLACEMENT = 61,
+			EFFECT_NOISE = 62,
+			EFFECT_RAINSPLASH = 63,
+			EFFECT_VLS_LIGHT = 64,
+			EFFECT_VLS = 65,
+			EFFECT_PIPBOY_SCREEN = 66,
+			EFFECT_HUD_GLASS = 67,
+			EFFECT_MOD_MENU = 68,
+			EFFECT_AO = 69,
+			EFFECT_SAO = 70,
+			EFFECT_SAO_CS = 71,
+			EFFECT_TOP_LEVEL_END = 72,
+			EFFECT_NIGHTVISION = EFFECT_TOP_LEVEL_END,
+			EFFECT_END = EFFECT_TOP_LEVEL_END,
+			EFFECT_SHADER_START = 72,
+			EFFECT_SHADER_COPY = EFFECT_SHADER_START,
+			EFFECT_SHADER_COPY_SCALE_BIAS = 73,
+			EFFECT_SHADER_COPY_VIS_ALPHA = 74,
+			EFFECT_SHADER_GREYSCALE = 75,
+			EFFECT_SHADER_DOWNSAMPLE_DEPTH = 76,
+			EFFECT_SHADER_COPY_STENCIL = 77,
+			EFFECT_SHADER_COPY_WATER_MASK = 78,
+			EFFECT_SHADER_COPY_SHADOWMAPTOARRAY = 79,
+			EFFECT_SHADER_REFRACTION = 80,
+			EFFECT_SHADER_DOUBLEVIS = 81,
+			EFFECT_SHADER_TEXTUREMASK = 82,
+			EFFECT_SHADER_MAP = 83,
+			EFFECT_SHADER_WORLD_CAMERA = 84,
+			EFFECT_SHADER_WORLD_CAMERA_NO_SKY_BLUR = 85,
+			EFFECT_SHADER_DEPTH_OF_FIELD = 86,
+			EFFECT_SHADER_DEPTH_OF_FIELD_FOGGED = 87,
+			EFFECT_SHADER_DEPTH_OF_FIELD_SPLIT_SCREEN = 88,
+			EFFECT_SHADER_BOKEH_DEPTH_OF_FIELD_PASS1 = 89,
+			EFFECT_SHADER_BOKEH_DEPTH_OF_FIELD_PASS2 = 90,
+			EFFECT_SHADER_BOKEH_DEPTH_OF_FIELD_PASS3 = 91,
+			EFFECT_SHADER_BOKEH_DEPTH_OF_FIELD_PASS4 = 92,
+			EFFECT_SHADER_BOKEH_DEPTH_OF_FIELD_PASS4_FOGGED = 93,
+			EFFECT_SHADER_DISTANT_BLUR = 94,
+			EFFECT_SHADER_DISTANT_BLUR_FOGGED = 95,
+			EFFECT_SHADER_RADIAL_BLUR = 96,
+			EFFECT_SHADER_RADIAL_BLUR_MED = 97,
+			EFFECT_SHADER_RADIAL_BLUR_HIGH = 98,
+			EFFECT_SHADER_HDR_BLENDINSHADER_CINEMATIC = 99,
+			EFFECT_SHADER_HDR_BLENDINSHADER_CINEMATIC_FADE = 100,
+			EFFECT_SHADER_HDR_DOWNSAMPLE16 = 101,
+			EFFECT_SHADER_HDR_DOWNSAMPLE4 = 102,
+			EFFECT_SHADER_HDR_DOWNSAMPLE16LUM = 103,
+			EFFECT_SHADER_HDR_DOWNSAMPLE4RGB2LUM = 104,
+			EFFECT_SHADER_HDR_DOWNSAMPLE4_LUMCLAMP = 105,
+			EFFECT_SHADER_HDR_DOWNSAMPLE4_LIGHTADAPT = 106,
+			EFFECT_SHADER_HDR_DOWNSAMPLE16_LUMCLAMP = 107,
+			EFFECT_SHADER_HDR_DOWNSAMPLE16_LIGHTADAPT = 108,
+			EFFECT_SHADER_HDR_DOWNSAMPLE4CS = 109,
+			EFFECT_SHADER_HDR_DOWNSAMPLE64RGB2LUMCS = 110,
+			EFFECT_SHADER_HDR_DOWNSAMPLE4LUMCS = 111,
+			EFFECT_SHADER_HDR_DOWNSAMPLE16LUMCS = 112,
+			EFFECT_SHADER_HDR_DOWNSAMPLE2_LIGHTADAPTCS = 113,
+			EFFECT_SHADER_BLUR_START = 114,
+			EFFECT_SHADER_BLUR3 = EFFECT_SHADER_BLUR_START,
+			EFFECT_SHADER_BLUR5 = 115,
+			EFFECT_SHADER_BLUR7 = 116,
+			EFFECT_SHADER_BLUR9 = 117,
+			EFFECT_SHADER_BLUR11 = 118,
+			EFFECT_SHADER_BLUR13 = 119,
+			EFFECT_SHADER_BLUR15 = 120,
+			EFFECT_SHADER_BLUR_END = 120,
+			EFFECT_SHADER_HDR_BLURX15_320CS = 121,
+			EFFECT_SHADER_HDR_BLURX15_480CS = 122,
+			EFFECT_SHADER_HDR_BLURX15_1024CS = 123,
+			EFFECT_SHADER_NONHDR_BLUR_START = 124,
+			EFFECT_SHADER_NONHDR_BLUR3 = 124,
+			EFFECT_SHADER_NONHDR_BLUR5 = 125,
+			EFFECT_SHADER_NONHDR_BLUR7 = 126,
+			EFFECT_SHADER_NONHDR_BLUR9 = 127,
+			EFFECT_SHADER_NONHDR_BLUR11 = 128,
+			EFFECT_SHADER_NONHDR_BLUR13 = 129,
+			EFFECT_SHADER_NONHDR_BLUR15 = 130,
+			EFFECT_SHADER_NONHDR_BLUR_END = EFFECT_SHADER_NONHDR_BLUR15,
+			EFFECT_SHADER_BRIGHTPASS_BLUR_START = 131,
+			EFFECT_SHADER_BRIGHTPASS_BLUR3 = EFFECT_SHADER_BRIGHTPASS_BLUR_START,
+			EFFECT_SHADER_BRIGHTPASS_BLUR5 = 132,
+			EFFECT_SHADER_BRIGHTPASS_BLUR7 = 133,
+			EFFECT_SHADER_BRIGHTPASS_BLUR9 = 134,
+			EFFECT_SHADER_BRIGHTPASS_BLUR11 = 135,
+			EFFECT_SHADER_BRIGHTPASS_BLUR13 = 136,
+			EFFECT_SHADER_BRIGHTPASS_BLUR15 = 137,
+			EFFECT_SHADER_BRIGHTPASS_BLUR_END = EFFECT_SHADER_BRIGHTPASS_BLUR15,
+			EFFECT_SHADER_BRIGHTPASS_HDR_BLURY15_180CS = 138,
+			EFFECT_SHADER_BRIGHTPASS_HDR_BLURY15_270CS = 139,
+			EFFECT_SHADER_BRIGHTPASS_HDR_BLURY15_1024CS = 140,
+			EFFECT_SHADER_WATER_DISPLACEMENT_START = 141,
+			EFFECT_SHADER_WATER_DISPLACEMENT_CLEAR_SIMULATION = EFFECT_SHADER_WATER_DISPLACEMENT_START,
+			EFFECT_SHADER_WATER_DISPLACEMENT_TEX_OFFSET = 142,
+			EFFECT_SHADER_WATER_DISPLACEMENT_WADING_RIPPLE = 143,
+			EFFECT_SHADER_WATER_DISPLACEMENT_RAIN_RIPPLE = 144,
+			EFFECT_SHADER_WATER_DISPLACEMENT_WADING_HEIGHTMAP = 145,
+			EFFECT_SHADER_WATER_DISPLACEMENT_RAIN_HEIGHTMAP = 146,
+			EFFECT_SHADER_WATER_DISPLACEMENT_BLEND_HEIGHTMAPS = 147,
+			EFFECT_SHADER_WATER_DISPLACEMENT_SMOOTH_HEIGHTMAP = 148,
+			EFFECT_SHADER_WATER_DISPLACEMENT_NORMALS = 149,
+			EFFECT_SHADER_WATER_DISPLACEMENT_END = 149,
+			EFFECT_SHADER_NOISE_SCROLL_AND_BLEND = 150,
+			EFFECT_SHADER_NOISE_NORMALMAP = 151,
+			EFFECT_SHADER_LOCAL_MAP = 152,
+			EFFECT_SHADER_LOCAL_MAP_COMPANION = 153,
+			EFFECT_SHADER_ALPHA_BLEND = 154,
+			EFFECT_SHADER_PIPBOY_SCREEN = 155,
+			EFFECT_SHADER_HUD_GLASS = 156,
+			EFFECT_SHADER_HUD_GLASS_DROPSHADOW = 157,
+			EFFECT_SHADER_HUD_GLASS_BLURY = 158,
+			EFFECT_SHADER_HUD_GLASS_BLURX = 159,
+			EFFECT_SHADER_HUD_GLASS_MARKERS = 160,
+			EFFECT_SHADER_VATS_TARGET_DEBUG = 161,
+			EFFECT_SHADER_VATS_TARGET = 162,
+			EFFECT_SHADER_MOD_MENU_EFFECT = 163,
+			EFFECT_SHADER_MOD_MENU_GLOW_COMPOSITE = 164,
+			EFFECT_SHADER_AO = 165,
+			EFFECT_SHADER_AO_BLUR = 166,
+			EFFECT_SHADER_VLS_SPOTLIGHT = 167,
+			EFFECT_SHADER_VLS_APPLICATION = 168,
+			EFFECT_SHADER_VLS_COMPOSITE = 169,
+			EFFECT_SHADER_VLS_SLICE_COORD = 170,
+			EFFECT_SHADER_VLS_SLICE_INTERP = 171,
+			EFFECT_SHADER_VLS_SLICE_STENCIL = 172,
+			EFFECT_SHADER_VLS_SLICE_SCATTER_RAY = 173,
+			EFFECT_SHADER_VLS_SLICE_SCATTER_INTERP = 174,
+			EFFECT_SHADER_VLS_SCATTER_ACCUM = 175,
+			EFFECT_SHADER_SAO_CAMERAZ = 176,
+			EFFECT_SHADER_SAO_MINIFY = 177,
+			EFFECT_SHADER_SAO_RAWAO = 178,
+			EFFECT_SHADER_SAO_BLUR_H = 179,
+			EFFECT_SHADER_SAO_BLUR_V = 180,
+			EFFECT_SHADER_SAO_RAWAO_EDITOR = 181,
+			EFFECT_SHADER_SAO_CAMERAZ_CS = 182,
+			EFFECT_SHADER_SAO_MINIFY_CS = 183,
+			EFFECT_SHADER_SAO_CAMERAZ_AND_MIPS_CS = 184,
+			EFFECT_SHADER_SAO_MIPS_CS = 185,
+			EFFECT_SHADER_SAO_RAWAO_CS = 186,
+			EFFECT_SHADER_SAO_BLUR_H_CS = 187,
+			EFFECT_SHADER_SAO_BLUR_V_CS = 188,
+			EFFECT_SHADER_MOTIONBLUR = 189,
+			EFFECT_SHADER_TEMPORAL_AA = 190,
+			EFFECT_SHADER_TEMPORAL_AA_MASKED = 191,
+			EFFECT_SHADER_TEMPORAL_AA_POWERARMOR = 192,
+			EFFECT_SHADER_GAMMA_LINEARIZE = 193,
+			EFFECT_SHADER_SUNBEAMS = 194,
+			EFFECT_SHADER_SSR_PREPASS = 195,
+			EFFECT_SHADER_SSR_RAYTRACING = 196,
+			EFFECT_SHADER_SSR_BLURH = 197,
+			EFFECT_SHADER_SSR_BLURV = 198,
+			EFFECT_SHADER_LENSFLARE = 199,
+			EFFECT_SHADER_RAINSPLASH_SPAWN = 200,
+			EFFECT_SHADER_RAINSPLASH_UPDATE = 201,
+			EFFECT_SHADER_RAINSPLASH_DRAW = 202,
+			EFFECT_SHADER_LENSFLAREVISIBILITY = 203,
+			EFFECT_SHADER_UPSAMPLE_DYNAMIC_RESOLUTION = 204,
+			EFFECT_SHADER_FULLSCREEN_COLOR = 205,
+			EFFECT_SHADER_HUDGLASS_CLEAR = 206,
+			EFFECT_SHADER_HUDGLASS_COPY = 207,
+			EFFECT_SHADER_CS_V_START = 208,
+			EFFECT_SHADER_ISBlur3_V_270_CS = 208,
+			EFFECT_SHADER_ISBlur5_V_270_CS = 209,
+			EFFECT_SHADER_ISBlur7_V_270_CS = 210,
+			EFFECT_SHADER_ISBlur9_V_270_CS = 211,
+			EFFECT_SHADER_ISBlur11_V_270_CS = 212,
+			EFFECT_SHADER_ISBlur13_V_270_CS = 213,
+			EFFECT_SHADER_ISBlur15_V_270_CS = 214,
+			EFFECT_SHADER_CS_V_END = 215,
+			EFFECT_SHADER_CS_H_START = 216,
+			EFFECT_SHADER_ISBlur3_H_480_CS = EFFECT_SHADER_CS_H_START,
+			EFFECT_SHADER_ISBlur5_H_480_CS = 217,
+			EFFECT_SHADER_ISBlur7_H_480_CS = 218,
+			EFFECT_SHADER_ISBlur9_H_480_CS = 219,
+			EFFECT_SHADER_ISBlur11_H_480_CS = 220,
+			EFFECT_SHADER_ISBlur13_H_480_CS = 221,
+			EFFECT_SHADER_ISBlur15_H_480_CS = 222,
+			EFFECT_SHADER_CS_H_END = 223,
+			EFFECT_SHADER_BRIGHTPASS_CS_V_START = 224,
+			EFFECT_SHADER_ISBrightPassBlur3_V_270_CS = 224,
+			EFFECT_SHADER_ISBrightPassBlur5_V_270_CS = 225,
+			EFFECT_SHADER_ISBrightPassBlur7_V_270_CS = 226,
+			EFFECT_SHADER_ISBrightPassBlur9_V_270_CS = 227,
+			EFFECT_SHADER_ISBrightPassBlur11_V_270_CS = 228,
+			EFFECT_SHADER_ISBrightPassBlur13_V_270_CS = 229,
+			EFFECT_SHADER_ISBrightPassBlur15_V_270_CS = 230,
+			EFFECT_SHADER_BRIGHTPASS_CS_V_END = 231
+		};
+
+		[[nodiscard]] static ImageSpaceManager* GetSingleton()
+		{
+			static REL::Relocation<ImageSpaceManager**> singleton{ ID::ImageSpaceManager::Singleton };
+			return *singleton;
+		}
+
+		// members
+		NiRect<std::int32_t>                 scissorRect;               // 000
+		NiTPrimitiveArray<ImageSpaceEffect*> effectList;                // 010
+		NiPointer<BSTriShape>                screenTriShape;            // 028
+		NiPointer<BSTriShape>                screenTriShapeColors;      // 030
+		NiPointer<BSTriShape>                dynamicScreenTriShape;     // 038
+		NiPointer<BSTriShape>                partialScreenTriShape;     // 040
+		bool                                 enablePartialRender;       // 048
+		std::int32_t                         mainTarget;                // 04C
+		NiColorA                             refractionTint;            // 050
+		const ImageSpaceBaseData*            baseData;                  // 060
+		const ImageSpaceBaseData*            overRideBaseData;          // 068
+		const ImageSpaceBaseData*            underwaterBaseData;        // 070
+		ImageSpaceBaseData*                  consoleBaseData;           // 078
+		ImageSpaceData                       currentEOFData;            // 080
+		ImageSpaceLUTData                    lutData;                   // 130
+		ImageSpaceLUTData*                   overrideLUTData;           // 1A0
+		float                                motionBlurIntensity;       // 1A8
+		float                                motionBlurMaxBlur;         // 1AC
+		std::uint32_t                        forceNoBokehDepthOfField;  // 1B0
+		bool                                 isReady;                   // 1B4
+		bool                                 saveTarget;                // 1B5
+		bool                                 useBokehDepthOfField;      // 1B6
+	};
+	static_assert(sizeof(ImageSpaceManager) == 0x1B8);
+}
@@ -0,0 +1,28 @@
+#pragma once
+
+#include "RE/I/ImageSpaceBaseData.h"
+
+namespace RE
+{
+	class ImageSpaceModData
+	{
+	public:
+		// members
+		float                            fadeAmount;            // 00
+		float                            fadeR;                 // 04
+		float                            fadeG;                 // 08
+		float                            fadeB;                 // 0C
+		float                            blurRadius;            // 10
+		float                            doubleVisionStrength;  // 14
+		float                            radiusBlurStrength;    // 18
+		float                            radiusBlurRampUp;      // 1C
+		float                            radiusBlurStart;       // 20
+		float                            radiusBlurRampDown;    // 24
+		float                            radiusBlurDownStart;   // 28
+		float                            radiusBlurCenterX;     // 2C
+		float                            radiusBlurCenterY;     // 30
+		ImageSpaceBaseData::DepthOfField depthOfField;          // 34
+		float                            motionBlurStrength;    // 4C
+	};
+	static_assert(sizeof(ImageSpaceModData) == 0x50);
+}
@@ -0,0 +1,17 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class TESImageSpaceModifierForm;
+
+	class ImageSpaceModifierFinder
+	{
+	public:
+		// members
+		TESImageSpaceModifierForm* modifier;        // 00
+		const BSFixedString&       modifierToFind;  // 08
+	};
+	static_assert(sizeof(ImageSpaceModifierFinder) == 0x10);
+}
@@ -0,0 +1,50 @@
+#pragma once
+
+#include "RE/N/NiObject.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class ImageSpaceModifierInstanceForm;
+	class NiAVObject;
+
+	class ImageSpaceModifierInstance :
+		public NiObject  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceModifierInstance };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceModifierInstance };
+
+		enum class FLAGS
+		{
+			kNone = 0,
+			kPermanent = 1 << 0,
+			kCrossfade = 1 << 1,
+			kPreviousCrossfade = 1 << 2,
+			kMenuIMOD = 1 << 3,
+			kStopped = 1 << 4
+		};
+
+		virtual ~ImageSpaceModifierInstance();  // 00
+
+		// add
+		virtual bool                            IsExpired();                    // 28
+		virtual void                            Apply() = 0;                    // 29
+		virtual void                            PrintInfo(char* a_buffer) = 0;  // 2A
+		virtual ImageSpaceModifierInstanceForm* IsForm();                       // 2B
+
+		void Stop()
+		{
+			using func_t = decltype(&ImageSpaceModifierInstance::Stop);
+			static REL::Relocation<func_t> func{ ID::ImageSpaceModifierInstance::Stop };
+			return func(this);
+		}
+
+		// members
+		float                               strength;  // 10
+		NiPointer<NiAVObject>               target;    // 18
+		float                               age;       // 20
+		REX::TEnumSet<FLAGS, std::uint32_t> flags;     // 24
+	};
+	static_assert(sizeof(ImageSpaceModifierInstance) == 0x28);
+}
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "RE/I/ImageSpaceModData.h"
+#include "RE/I/ImageSpaceModifierInstanceTemp.h"
+
+namespace RE
+{
+	class ImageSpaceModifierInstanceDOF :
+		public ImageSpaceModifierInstanceTemp  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceModifierInstanceDOF };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceModifierInstanceDOF };
+
+		enum class DepthOfFieldMode
+		{
+			kFrontBack = 0,
+			kFront,
+			kBack,
+			kNone,
+		};
+
+		virtual ~ImageSpaceModifierInstanceDOF();  // 00
+
+		// override (ImageSpaceModifierInstanceTemp)
+		virtual void Apply() override;                    // 29
+		virtual void PrintInfo(char* a_buffer) override;  // 2A
+
+		static ImageSpaceModifierInstanceDOF* Trigger(
+			float            a_distance,
+			float            a_range,
+			float            a_vignetteRadius,
+			float            a_vignetteStrength,
+			DepthOfFieldMode a_mode,
+			float            a_strength,
+			float            a_duration)
+		{
+			using func_t = decltype(&ImageSpaceModifierInstanceDOF::Trigger);
+			static REL::Relocation<func_t> func{ ID::ImageSpaceModifierInstanceDOF::Trigger };
+			return func(a_distance, a_range, a_vignetteRadius, a_vignetteStrength, a_mode, a_strength, a_duration);
+		}
+
+		// members
+		ImageSpaceModData data;  // 30
+	};
+	static_assert(sizeof(ImageSpaceModifierInstanceDOF) == 0x80);
+}
@@ -0,0 +1,60 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/I/ImageSpaceModifierInstance.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class ImageSpaceModifierInstanceForm :
+		public ImageSpaceModifierInstance
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceModifierInstanceForm };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceModifierInstanceForm };
+
+		virtual ~ImageSpaceModifierInstanceForm();  // 00
+
+		// override (ImageSpaceModifierInstance)
+		virtual bool                            IsExpired() override;                // 28
+		virtual void                            Apply() override;                    // 29
+		virtual void                            PrintInfo(char* a_buffer) override;  // 2A
+		virtual ImageSpaceModifierInstanceForm* IsForm() override;                   // 2B
+
+		static ImageSpaceModifierInstanceForm* Trigger(TESImageSpaceModifier* a_mod, float a_strength, NiAVObject* a_target)
+		{
+			using func_t = ImageSpaceModifierInstanceForm* (*)(TESImageSpaceModifier*, float, NiAVObject*);
+			static REL::Relocation<func_t> func{ ID::ImageSpaceModifierInstanceForm::Trigger1 };
+			return func(a_mod, a_strength, a_target);
+		}
+
+		static ImageSpaceModifierInstanceForm* Trigger(const BSFixedString& a_name)
+		{
+			using func_t = ImageSpaceModifierInstanceForm* (*)(const BSFixedString&);
+			static REL::Relocation<func_t> func{ ID::ImageSpaceModifierInstanceForm::Trigger2 };
+			return func(a_name);
+		}
+
+		static void Stop(TESImageSpaceModifier* a_mod)
+		{
+			using func_t = void (*)(TESImageSpaceModifier*);
+			static REL::Relocation<func_t> func{ ID::ImageSpaceModifierInstanceForm::Stop1 };
+			return func(a_mod);
+		}
+
+		static void Stop(const BSFixedString& a_name)
+		{
+			using func_t = void (*)(const BSFixedString&);
+			static REL::Relocation<func_t> func{ ID::ImageSpaceModifierInstanceForm::Stop2 };
+			return func(a_name);
+		}
+
+		// members
+		TESImageSpaceModifier* imageSpaceMod;      // 28
+		TESImageSpaceModifier* lastImageSpaceMod;  // 30
+		float                  lastStrength;       // 38
+		NiPointer<NiAVObject>  lastTarget;         // 40
+		float                  transitionTime;     // 48
+	};
+	static_assert(sizeof(ImageSpaceModifierInstanceForm) == 0x50);
+}
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/I/ImageSpaceModData.h"
+#include "RE/I/ImageSpaceModifierInstanceTemp.h"
+
+namespace RE
+{
+	class ImageSpaceModifierInstanceRB :
+		public ImageSpaceModifierInstanceTemp
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceModifierInstanceRB };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceModifierInstanceRB };
+
+		virtual ~ImageSpaceModifierInstanceRB();  // 00
+
+		// override (ImageSpaceModifierInstanceTemp)
+		virtual void Apply() override;                    // 29
+		virtual void PrintInfo(char* a_buffer) override;  // 2A
+
+		// members
+		ImageSpaceModData data;  // 30
+	};
+	static_assert(sizeof(ImageSpaceModifierInstanceRB) == 0x80);
+}
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/I/ImageSpaceModifierInstance.h"
+
+namespace RE
+{
+	class ImageSpaceModifierInstanceTemp :
+		public ImageSpaceModifierInstance  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceModifierInstanceTemp };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceModifierInstanceTemp };
+
+		virtual ~ImageSpaceModifierInstanceTemp();  // 00
+
+		// override (ImageSpaceModifierInstance)
+		virtual bool IsExpired() override;                // 28
+		virtual void PrintInfo(char* a_buffer) override;  // 2A
+
+		// members
+		float duration;  // 28
+	};
+	static_assert(sizeof(ImageSpaceModifierInstanceTemp) == 0x30);
+}
@@ -0,0 +1,27 @@
+#pragma once
+
+namespace RE
+{
+	class NiTexture;
+
+	namespace BSGraphics
+	{
+		enum class TextureAddressMode;
+		enum class TextureFilterMode;
+	}
+
+	class ImageSpaceTexture
+	{
+	public:
+		// members
+		bool                           forceAniso;      // 00
+		NiTexture*                     texture;         // 08
+		std::int32_t                   renderTarget;    // 10
+		std::int32_t                   depthBuffer;     // 14
+		std::int32_t                   stencilBuffer;   // 18
+		BSGraphics::TextureFilterMode  filterMode;      // 1C
+		BSGraphics::TextureAddressMode clampMode;       // 20
+		bool                           acquiredTarget;  // 24
+	};
+	static_assert(sizeof(ImageSpaceTexture) == 0x28);
+}
@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class ImpactResult : std::int32_t
+	{
+		kNone = 0x0,
+		kDestroy = 0x1,
+		kBounce = 0x2,
+		kImpale = 0x3,
+		kStick = 0x4
+	};
+}
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "RE/B/BGSDestructibleObjectForm.h"
+#include "RE/B/BGSEquipType.h"
+#include "RE/B/BGSModelMaterialSwap.h"
+#include "RE/B/BGSPickupPutdownSounds.h"
+#include "RE/M/MagicItem.h"
+#include "RE/T/TESIcon.h"
+#include "RE/T/TESValueForm.h"
+#include "RE/T/TESWeightForm.h"
+
+namespace RE
+{
+	class __declspec(novtable) IngredientItem :
+		public MagicItem,                  // 000
+		public BGSModelMaterialSwap,       // 0D0
+		public TESIcon,                    // 110
+		public TESWeightForm,              // 120
+		public BGSEquipType,               // 130
+		public BGSDestructibleObjectForm,  // 140
+		public BGSPickupPutdownSounds,     // 150
+		public TESValueForm                // 168
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::IngredientItem };
+		static constexpr auto VTABLE{ VTABLE::IngredientItem };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kINGR };
+
+		class GameData
+		{
+		public:
+			// members
+			std::uint16_t knownEffectFlags;  // 0
+			std::uint16_t playerUses;        // 2
+		};
+		static_assert(sizeof(GameData) == 0x4);
+
+		// members
+		MagicItem::Data data;      // 178
+		GameData        gamedata;  // 180
+	};
+	static_assert(sizeof(IngredientItem) == 0x188);
+}
@@ -0,0 +1,85 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/I/INPUT_DEVICE.h"
+#include "RE/I/INPUT_EVENT_TYPE.h"
+
+namespace RE
+{
+	class IDEvent;
+
+	class __declspec(novtable) InputEvent
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::InputEvent };
+		static constexpr auto VTABLE{ VTABLE::InputEvent };
+
+		enum class HANDLED_RESULT : std::int32_t
+		{
+			kUnhandled,
+			kContinue,
+			kStop
+		};
+
+		virtual ~InputEvent() = default;  // 00
+
+		// add
+		virtual bool                 HasIDCode() const { return false; }  // 02
+		virtual const BSFixedString& QUserEvent() const;                  // 03
+
+		template <class T>
+		[[nodiscard]] T* As() noexcept  //
+			requires(std::derived_from<T, InputEvent> &&
+					 !std::same_as<std::decay_t<T>, IDEvent>)
+		{
+			if (*eventType == T::TYPE) {
+				return static_cast<T*>(this);
+			} else {
+				return nullptr;
+			}
+		}
+
+		template <class T>
+		[[nodiscard]] const T* As() const noexcept  //
+			requires(std::derived_from<T, InputEvent> &&
+					 !std::same_as<std::decay_t<T>, IDEvent>)
+		{
+			if (*eventType == T::TYPE) {
+				return static_cast<const T*>(this);
+			} else {
+				return nullptr;
+			}
+		}
+
+		template <class T>
+		[[nodiscard]] T* As()  //
+			requires(std::same_as<std::decay_t<T>, IDEvent>)
+		{
+			if (HasIDCode()) {
+				return static_cast<T*>(this);
+			} else {
+				return nullptr;
+			}
+		}
+
+		template <class T>
+		[[nodiscard]] const T* As() const  //
+			requires(std::same_as<std::decay_t<T>, IDEvent>)
+		{
+			if (HasIDCode()) {
+				return static_cast<const T*>(this);
+			} else {
+				return nullptr;
+			}
+		}
+
+		// members
+		REX::TEnumSet<INPUT_DEVICE, std::int32_t>     device{ INPUT_DEVICE::kNone };               // 08
+		std::int32_t                                  deviceID{ 0 };                               // 0C
+		REX::TEnumSet<INPUT_EVENT_TYPE, std::int32_t> eventType{ INPUT_EVENT_TYPE::kNone };        // 10
+		InputEvent*                                   next{ nullptr };                             // 18
+		std::uint32_t                                 timeCode{ static_cast<std::uint32_t>(-1) };  // 20
+		REX::TEnumSet<HANDLED_RESULT, std::int32_t>   handled{ HANDLED_RESULT::kUnhandled };       // 24
+	};
+	static_assert(sizeof(InputEvent) == 0x28);
+}
@@ -0,0 +1,455 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+#include "RE/N/NiColor.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiPointer.h"
+#include "RE/U/UIShaderFXInfo.h"
+#include "Scaleform/G/GFx_Movie.h"
+
+namespace RE
+{
+	enum class UI_DEPTH_PRIORITY;
+	class BSGeometry;
+	class BSShaderAccumulator;
+	class NiAVObject;
+	class NiCamera;
+	class NiDirectionalLight;
+	class NiLight;
+	class ShadowSceneNode;
+
+	namespace Interface3D
+	{
+		enum class BackgroundMode
+		{
+			kLive = 0x0,
+			kStatic = 0x1,
+			kSolidColor = 0x2
+		};
+
+		enum class PostEffect
+		{
+			kNone = 0x0,
+			kPipboy = 0x1,
+			kHUDGlass = 0x2,
+			kHUDGlassWithMod = 0x3,
+			kModMenu = 0x4,
+			kModMenuHighlightAll = 0x5,
+			kModMenuHighlightAllNoPulseOrScanLines = 0x6
+		};
+
+		enum class HighlightEffect
+		{
+			kNone = 0x0,
+			kVATS = 0x1
+		};
+
+		enum class OffscreenMenuSize
+		{
+			kPipboy = 0x0,
+			kFullFrame = 0x1,
+			kFullFrameText = 0x2
+		};
+
+		enum class ScreenMode
+		{
+			kNone = 0x0,
+			kWorldAttached = 0x1,
+			kScreenAttached = 0x2
+		};
+
+		enum class OffscreenMenuBlendMode
+		{
+			kAdditive = 0x0,
+			kAlpha = 0x1
+		};
+
+		enum class LightType
+		{
+			kSpot = 0x0,
+			kShadowSpot = 0x1,
+			kPoint = 0x2
+		};
+
+		class OldScreenEffectControl
+		{
+		public:
+			// members
+			NiPoint2 uvOffset;            // 00
+			float    burstAmount;         // 08
+			float    brightness;          // 0C
+			float    vScanState;          // 10
+			float    vScanRate;           // 14
+			float    pulseIntensity;      // 18
+			float    pulseRate;           // 1C
+			float    flickerMinDelay;     // 20
+			float    flickerMaxDelay;     // 24
+			float    flickerMinDuration;  // 28
+			float    flickerMaxDuration;  // 2C
+			float    flickerFrequency;    // 30
+			float    flickerBrightness;   // 34
+			float    vScanDelayMin;       // 38
+			float    vScanDelayMax;       // 3C
+			bool     doScanlines;         // 40
+			float    burstState;          // 44
+			float    burstFadeRate;       // 48
+			float    shudderState;        // 4C
+			float    vScanDelay;          // 50
+			float    flickerDelay;        // 54
+			float    vHoldState;          // 58
+			float    shudderScale;        // 5C
+			float    shudderLength;       // 60
+			float    vHoldRate;           // 64
+			float    time;                // 68
+			bool     flickering;          // 6C
+		};
+		static_assert(sizeof(OldScreenEffectControl) == 0x70);
+
+		class Renderer
+		{
+		public:
+			class LightParams
+			{
+			public:
+				// members
+				REX::TEnumSet<LightType, std::int32_t> type;          // 00
+				float                                  spotFOV;       // 04
+				NiPoint3                               lookAtPos;     // 08
+				NiPointer<NiAVObject>                  lookAtObject;  // 18
+				NiPointer<NiLight>                     light;         // 20
+			};
+			static_assert(sizeof(LightParams) == 0x28);
+
+			static Renderer* Create(const BSFixedString& a_name, UI_DEPTH_PRIORITY a_depth, float a_fov, bool a_alwaysRenderWhenEnabled)
+			{
+				using func_t = decltype(&Renderer::Create);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Create };
+				return func(a_name, a_depth, a_fov, a_alwaysRenderWhenEnabled);
+			}
+
+			[[nodiscard]] static Renderer* GetByName(const BSFixedString& a_name)
+			{
+				using func_t = decltype(&Renderer::GetByName);
+				static REL::Relocation<func_t> func{ ID::Interface3D::GetByName };
+				return func(a_name);
+			}
+
+			void MainScreen_AddPointLight(
+				NiPoint3 a_translation,
+				NiColor  a_diffuse,
+				float    a_radius,
+				float    a_dimmerVal)
+			{
+				using func_t = decltype(&Renderer::MainScreen_AddPointLight);
+				static REL::Relocation<func_t> func{ ID::Interface3D::MainScreen_AddPointLight };
+				func(this, a_translation, a_diffuse, a_radius, a_dimmerVal);
+			}
+
+			void MainScreen_AddSpotLight(
+				NiPoint3    a_translation,
+				NiPoint3    a_lookAtPosition,
+				NiAVObject* a_lookAtObject,
+				float       a_fov,
+				NiColor     a_diffuse,
+				float       a_radius,
+				float       a_dimmerVal,
+				bool        a_castShadows)
+			{
+				using func_t = decltype(&Renderer::MainScreen_AddSpotLight);
+				static REL::Relocation<func_t> func{ ID::Interface3D::MainScreen_AddSpotLight };
+				func(this, a_translation, a_lookAtPosition, a_lookAtObject, a_fov, a_diffuse, a_radius, a_dimmerVal, a_castShadows);
+			}
+
+			void MainScreen_ClearLights()
+			{
+				using func_t = decltype(&Renderer::MainScreen_ClearLights);
+				static REL::Relocation<func_t> func{ ID::Interface3D::MainScreen_ClearLights };
+				func(this);
+			}
+
+			void MainScreen_EnableAO(bool a_value)
+			{
+				enableAO = a_value;
+			}
+
+			void MainScreen_EnableScreenAttached3DMasking(
+				const char* a_maskedGeomName,
+				const char* a_maskedMaterialName)
+			{
+				maskedGeomName = a_maskedGeomName;
+				maskedMaterialName = a_maskedMaterialName;
+			}
+
+			void MainScreen_RegisterGeometryRequiringFullViewport(NiAVObject* a_geometry)
+			{
+				elementRequiringFullVieport = a_geometry;
+			}
+
+			void MainScreen_SetBackgroundMode(BackgroundMode a_mode)
+			{
+				bgmode = a_mode;
+			}
+
+			void MainScreen_SetClearDepthStencil(bool a_clear)
+			{
+				clearDepthStencilMainScreen = a_clear;
+			}
+
+			void MainScreen_SetMenuBlendMode(OffscreenMenuBlendMode a_mode)
+			{
+				menuBlend = a_mode;
+			}
+
+			void MainScreen_SetMenuIntensity(float a_diffuse, float a_emit)
+			{
+				menuDiffuseIntensity = a_diffuse;
+				menuEmitIntensity = a_emit;
+			}
+
+			void MainScreen_SetOpacityAlpha(float a_opacityAlpha)
+			{
+				opacityAlpha = a_opacityAlpha;
+			}
+
+			void MainScreen_SetPostAA(bool a_value)
+			{
+				postAA = a_value;
+			}
+
+			void MainScreen_SetScreenAttached3D(NiAVObject* a_root3D)
+			{
+				using func_t = decltype(&Renderer::MainScreen_SetScreenAttached3D);
+				static REL::Relocation<func_t> func{ ID::Interface3D::MainScreen_SetScreenAttached3D };
+				func(this, a_root3D);
+			}
+
+			void MainScreen_SetUseDeferredRenderer(bool a_value)
+			{
+				defRenderMainScreen = a_value;
+			}
+
+			void MainScreen_SetWorldAttached3D(NiAVObject* a_root3D)
+			{
+				using func_t = decltype(&Renderer::MainScreen_SetWorldAttached3D);
+				static REL::Relocation<func_t> func{ ID::Interface3D::MainScreen_SetWorldAttached3D };
+				func(this, a_root3D);
+			}
+
+			void MainScreen_SetWorldAttachedMenuIntensity(float a_diffuse, float a_emit)
+			{
+				menuDiffuseIntensityWA = a_diffuse;
+				menuEmitIntensityWA = a_emit;
+			}
+
+			void MainScreen_SetHideScreenWhenDisabled(bool a_value)
+			{
+				hideScreenWhenDisabled = a_value;
+			}
+
+			void Offscreen_AddLight(
+				NiPoint3 a_translation,
+				NiColor  a_diffuse,
+				NiColor  a_specular,
+				float    a_dimmerVal)
+			{
+				using func_t = decltype(&Renderer::Offscreen_AddLight);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_AddLight };
+				func(this, a_translation, a_diffuse, a_specular, a_dimmerVal);
+			}
+
+			void Offscreen_Clear3D()
+			{
+				using func_t = decltype(&Renderer::Offscreen_Clear3D);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_Clear3D };
+				func(this);
+			}
+
+			void Offscreen_ClearLights()
+			{
+				using func_t = decltype(&Renderer::Offscreen_ClearLights);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_ClearLights };
+				func(this);
+			}
+
+			void Offscreen_Enable3D(bool a_value)
+			{
+				offscreen3DEnabled = a_value;
+			}
+
+			std::uint32_t Offscreen_GetRenderTargetHeight()
+			{
+				using func_t = decltype(&Renderer::Offscreen_GetRenderTargetHeight);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_GetRenderTargetHeight };
+				return func(this);
+			}
+
+			std::uint32_t Offscreen_GetRenderTargetWidth()
+			{
+				using func_t = decltype(&Renderer::Offscreen_GetRenderTargetWidth);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_GetRenderTargetWidth };
+				return func(this);
+			}
+
+			void Offscreen_Set3D(NiAVObject* a_3D)
+			{
+				using func_t = decltype(&Renderer::Offscreen_Set3D);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_Set3D };
+				func(this, a_3D);
+			}
+
+			void Offscreen_SetBackgroundColor(const NiColorA& a_color)
+			{
+				clearColor = a_color;
+			}
+
+			void Offscreen_SetClearDepthStencil(bool a_clear)
+			{
+				clearDepthStencilOffscreen = a_clear;
+			}
+
+			void Offscreen_SetClearRenderTarget(bool a_clear)
+			{
+				clearRenderTarget = a_clear;
+			}
+
+			void Offscreen_SetDebugMode(bool a_on, bool a_small, std::uint32_t a_target)
+			{
+				using func_t = decltype(&Renderer::Offscreen_SetDebugMode);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_SetDebugMode };
+				func(this, a_on, a_small, a_target);
+			}
+
+			void Offscreen_SetDirectionalLight(
+				float   a_xyPlaneAngle,
+				float   a_zAngle,
+				NiColor a_diffuse,
+				float   a_dimmerVal)
+			{
+				using func_t = decltype(&Renderer::Offscreen_SetDirectionalLight);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Offscreen_SetDirectionalLight };
+				func(this, a_xyPlaneAngle, a_zAngle, a_diffuse, a_dimmerVal);
+			}
+
+			void Offscreen_SetDisplayMode(
+				ScreenMode  a_mode,
+				const char* a_screenGeomName,
+				const char* a_screenMaterialName)
+			{
+				screenmode = a_mode;
+				screenGeomName = a_screenGeomName;
+				screenMaterialName = a_screenMaterialName;
+			}
+
+			void Offscreen_SetPostEffect(PostEffect a_effect)
+			{
+				postfx = a_effect;
+			}
+
+			void Offscreen_SetRenderTargetSize(OffscreenMenuSize a_size)
+			{
+				omsize = a_size;
+			}
+
+			void Offscreen_SetUseLongRangeCamera(bool a_use)
+			{
+				useLongRangeCamera = a_use;
+			}
+
+			void Enable(bool a_unhideGeometries = false)
+			{
+				using func_t = decltype(&Renderer::Enable);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Enable };
+				func(this, a_unhideGeometries);
+			}
+
+			void Disable()
+			{
+				using func_t = decltype(&Renderer::Disable);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Disable };
+				func(this);
+			}
+
+			static void DisableAll(bool a_disableAll)
+			{
+				using func_t = decltype(&Renderer::DisableAll);
+				static REL::Relocation<func_t> func{ ID::Interface3D::DisableAll };
+				func(a_disableAll);
+			}
+
+			void Release()
+			{
+				using func_t = decltype(&Renderer::Release);
+				static REL::Relocation<func_t> func{ ID::Interface3D::Release };
+				func(this);
+			}
+
+			void SetViewport(Scaleform::GFx::Movie& a_ui, const NiRect<float>& a_renderArea)
+			{
+				using func_t = decltype(&Renderer::SetViewport);
+				static REL::Relocation<func_t> func{ ID::Interface3D::SetViewport };
+				func(this, a_ui, a_renderArea);
+			}
+
+			// members
+			BSTAlignedArray<UIShaderFXInfo>                     colorFXInfos;                 // 000
+			BSTAlignedArray<UIShaderFXInfo>                     backgroundFXInfos;            // 018
+			BSReadWriteLock                                     cachedQuadsLock;              // 030
+			NiColorA                                            clearColor;                   // 038
+			float                                               opacityAlpha;                 // 048
+			bool                                                enabled;                      // 04C
+			bool                                                offscreen3DEnabled;           // 04D
+			bool                                                hideScreenWhenDisabled;       // 04E
+			bool                                                usePremultAlpha;              // 04F
+			bool                                                clearRenderTarget;            // 050
+			bool                                                clearDepthStencilMainScreen;  // 051
+			bool                                                clearDepthStencilOffscreen;   // 052
+			bool                                                postAA;                       // 053
+			bool                                                useFullPremultAlpha;          // 054
+			bool                                                alwaysRenderWhenEnabled;      // 055
+			bool                                                defRenderMainScreen;          // 056
+			bool                                                enableAO;                     // 057
+			bool                                                useLongRangeCamera;           // 058
+			bool                                                needsLightSetup;              // 059
+			bool                                                needsLightSetupOffscreen;     // 05A
+			REX::TEnumSet<BackgroundMode, std::int32_t>         bgmode;                       // 05C
+			REX::TEnumSet<PostEffect, std::int32_t>             postfx;                       // 060
+			REX::TEnumSet<HighlightEffect, std::int32_t>        highlightfx;                  // 064
+			REX::TEnumSet<OffscreenMenuSize, std::int32_t>      omsize;                       // 068
+			REX::TEnumSet<ScreenMode, std::int32_t>             screenmode;                   // 06C
+			REX::TEnumSet<OffscreenMenuBlendMode, std::int32_t> menuBlend;                    // 070
+			REX::TEnumSet<UI_DEPTH_PRIORITY, std::int32_t>      depth;                        // 074
+			NiPointer<NiAVObject>                               worldAttachedElementRoot;     // 078
+			NiPointer<NiAVObject>                               screenAttachedElementRoot;    // 080
+			NiPointer<NiAVObject>                               offscreenElement;             // 088
+			BSTArray<NiPointer<BSGeometry>>                     displayGeometry;              // 090
+			NiAVObject*                                         elementRequiringFullVieport;  // 0A8
+			NiAVObject*                                         highlightedElement;           // 0B0
+			bool                                                highlightOffscreen;           // 0B8
+			OldScreenEffectControl                              pipfx;                        // 0BC
+			OldScreenEffectControl                              vatsfx;                       // 12C
+			NiPointer<BSShaderAccumulator>                      accum;                        // 1A0
+			NiPointer<NiCamera>                                 pipboyAspect;                 // 1A8
+			NiPointer<NiCamera>                                 nativeAspect;                 // 1B0
+			NiPointer<NiCamera>                                 nativeAspectLongRange;        // 1B8
+			std::int32_t                                        customRenderTarget;           // 1C0
+			std::int32_t                                        customSwapTarget;             // 1C4
+			BSTArray<LightParams>                               mainLights;                   // 1C8
+			BSTArray<LightParams>                               offscreenLights;              // 1E0
+			float                                               menuDiffuseIntensity;         // 1F8
+			float                                               menuEmitIntensity;            // 1FC
+			float                                               menuDiffuseIntensityWA;       // 200
+			float                                               menuEmitIntensityWA;          // 204
+			BSFixedString                                       name;                         // 208
+			BSFixedString                                       screenGeomName;               // 210
+			BSFixedString                                       screenMaterialName;           // 218
+			BSFixedString                                       maskedGeomName;               // 220
+			BSFixedString                                       maskedMaterialName;           // 228
+			NiDirectionalLight*                                 directionalLight;             // 230
+			NiPointer<ShadowSceneNode>                          screenSSN;                    // 238
+			NiPointer<ShadowSceneNode>                          offscreenSSN;                 // 240
+		};
+		static_assert(sizeof(Renderer) == 0x248);
+	}
+}
@@ -0,0 +1,117 @@
+#pragma once
+
+#include "RE/B/BGSInventoryItem.h"
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSInputEventUser.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/N/NiMatrix3.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiPointer.h"
+#include "RE/N/NiQuaternion.h"
+
+namespace RE
+{
+	class ExtraDataList;
+	class LoadedInventoryModel;
+
+	namespace nsInventory3DManager
+	{
+		class NewInventoryMenuItemLoadTask;
+	}
+
+	class __declspec(novtable) Inventory3DManager :
+		public BSInputEventUser  // 000
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::Inventory3DManager };
+		static constexpr auto VTABLE{ VTABLE::Inventory3DManager };
+
+		void Begin3D()
+		{
+			using func_t = decltype(&Inventory3DManager::Begin3D);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::Begin3D };
+			return func(this);
+		}
+
+		void ClearModel()
+		{
+			using func_t = decltype(&Inventory3DManager::ClearModel);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::ClearModel };
+			return func(this);
+		}
+
+		void DisableRendering(const BSFixedString& a_userID)
+		{
+			using func_t = decltype(&Inventory3DManager::DisableRendering);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::DisableRendering };
+			return func(this, a_userID);
+		}
+
+		void EnableRendering(const BSFixedString& a_userID)
+		{
+			using func_t = decltype(&Inventory3DManager::EnableRendering);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::EnableRendering };
+			return func(this, a_userID);
+		}
+
+		void End3D()
+		{
+			using func_t = decltype(&Inventory3DManager::End3D);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::End3D };
+			return func(this);
+		}
+
+		void SetModelScale(float a_scale)
+		{
+			using func_t = decltype(&Inventory3DManager::SetModelScale);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::SetModelScale };
+			return func(this, a_scale);
+		}
+
+		void SetModelScreenPosition(const NiPoint3& a_position, bool a_screenCoords)
+		{
+			using func_t = decltype(&Inventory3DManager::SetModelScreenPosition);
+			static REL::Relocation<func_t> func{ ID::Inventory3DManager::SetModelScreenPosition };
+			return func(this, a_position, a_screenCoords);
+		}
+
+		// members
+		bool                                                          useBoundForScale: 1;             // 010:0
+		bool                                                          startedZoomThisFrame: 1;         // 010:1
+		bool                                                          useStoredModelPosition: 1;       // 010:2
+		bool                                                          rotating: 1;                     // 010:3
+		bool                                                          modelPositionInScreenCoords: 1;  // 010:4
+		bool                                                          centerOnBoundCenter: 1;          // 010:5
+		NiPoint3                                                      modelPosition;                   // 014
+		float                                                         modelScale;                      // 020
+		BSTArray<LoadedInventoryModel>                                loadedModels;                    // 030
+		NiPoint3                                                      initialPosition;                 // 048
+		NiPoint3                                                      storedPostion;                   // 054
+		NiMatrix3                                                     initialRotation;                 // 060
+		NiQuaternion                                                  storedRotation;                  // 090
+		NiPoint2                                                      previousInput;                   // 0A0
+		NiPointer<nsInventory3DManager::NewInventoryMenuItemLoadTask> loadTask;                        // 0A8
+		TESObjectREFR*                                                tempRef;                         // 0B0
+		BSTSmartPointer<ExtraDataList>                                originalExtra;                   // 0B8
+		BSFixedString                                                 str3DRendererName;               // 0C0
+		BGSInventoryItem                                              queuedDisplayItem;               // 0C8
+		std::uint32_t                                                 itemExtraIndex;                  // 0D8
+		TESForm*                                                      itemBase;                        // 0E0
+		std::int8_t                                                   disableInputUserCount;           // 0E8
+		BSTSet<BSFixedString>                                         disableRendererUsers;            // 0F0
+		float                                                         storedXRotation;                 // 120
+		float                                                         zoomDirection;                   // 124
+		float                                                         zoomProgress;                    // 128
+		float                                                         minZoomModifier;                 // 12C
+		float                                                         maxZoomModifier;                 // 130
+		std::uint32_t                                                 hightlightedPart;                // 134
+		bool                                                          queueShowItem;                   // 138
+		bool                                                          mouseRotation;                   // 139
+		bool                                                          prevUsesCursorFlag;              // 13A
+		bool                                                          prevUpdateUsesCursorFlag;        // 13B
+		bool                                                          addedLightsToScene;              // 13C
+	};
+	static_assert(sizeof(Inventory3DManager) == 0x140);
+}
@@ -0,0 +1,48 @@
+#pragma once
+
+#include "RE/B/BSCRC32.h"
+
+namespace RE
+{
+	class BGSInventoryItem;
+
+	namespace InventoryInterface
+	{
+		class CountChangedEvent
+		{
+		public:
+			// members
+			std::uint32_t inventoryOwnerID;  // 00
+			std::uint32_t itemID;            // 04
+			std::int32_t  newCount;          // 08
+			std::int32_t  oldCount;          // 0C
+		};
+		static_assert(sizeof(CountChangedEvent) == 0x10);
+
+		class FavoriteChangedEvent
+		{
+		public:
+			~FavoriteChangedEvent() noexcept {}  // intentional
+
+			// members
+			BGSInventoryItem* itemAffected;  // 0
+		};
+		static_assert(sizeof(FavoriteChangedEvent) == 0x8);
+
+		class Handle
+		{
+		public:
+			~Handle() noexcept {}  // intentional
+
+			// members
+			std::uint32_t id;  // 0
+		};
+		static_assert(sizeof(Handle) == 0x4);
+	}
+
+	template <>
+	struct BSCRC32<InventoryInterface::Handle>
+	{
+		[[nodiscard]] std::uint32_t operator()(InventoryInterface::Handle a_data) const noexcept;
+	};
+}
@@ -0,0 +1,53 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/I/InventoryUserUIInterfaceEntry.h"
+#include "Scaleform/G/GFx_Value.h"
+
+namespace RE
+{
+	class InventoryItemDisplayData
+	{
+	public:
+		InventoryItemDisplayData(
+			const ObjectRefHandle                a_inventoryRef,
+			const InventoryUserUIInterfaceEntry& a_entry)
+		{
+			ctor(a_inventoryRef, a_entry);
+		}
+
+		void PopulateFlashObject(Scaleform::GFx::Value& a_flashObject)
+		{
+			a_flashObject.SetMember("text"sv, itemName.c_str());
+			a_flashObject.SetMember("count"sv, itemCount);
+			a_flashObject.SetMember("equipState"sv, equipState);
+			a_flashObject.SetMember("filterFlag"sv, filterFlag);
+			a_flashObject.SetMember("isLegendary"sv, isLegendary);
+			a_flashObject.SetMember("favorite"sv, isFavorite);
+			a_flashObject.SetMember("taggedForSearch"sv, isTaggedForSearch);
+			a_flashObject.SetMember("isBetterThanEquippedItem"sv, isBetterThanEquippedItem);
+		}
+
+		// members
+		BSFixedStringCS itemName;                           // 00
+		std::uint32_t   itemCount{ 0 };                     // 08
+		std::uint32_t   equipState{ 0 };                    // 0C
+		std::uint32_t   filterFlag{ 0 };                    // 10
+		bool            isLegendary{ false };               // 14
+		bool            isFavorite{ false };                // 15
+		bool            isTaggedForSearch{ false };         // 16
+		bool            isBetterThanEquippedItem{ false };  // 17
+
+	private:
+		InventoryItemDisplayData* ctor(
+			const ObjectRefHandle                a_inventoryRef,
+			const InventoryUserUIInterfaceEntry& a_entry)
+		{
+			using func_t = decltype(&InventoryItemDisplayData::ctor);
+			static REL::Relocation<func_t> func{ ID::InventoryItemDisplayData::ctor };
+			return func(this, a_inventoryRef, a_entry);
+		}
+	};
+	static_assert(sizeof(InventoryItemDisplayData) == 0x18);
+}
@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTEvent.h"
+#include "RE/I/InventoryUserUIInterfaceEntry.h"
+
+namespace RE
+{
+	class InvInterfaceStateChangeEvent;
+
+	class __declspec(novtable) InventoryUserUIInterface :
+		public BSTEventSource<InvInterfaceStateChangeEvent>  // 00
+	{
+	public:
+		// members
+		ObjectRefHandle                         inventoryRef;    // 58
+		BSTArray<InventoryUserUIInterfaceEntry> stackedEntries;  // 60
+		bool                                    entriesInvalid;  // 78
+	};
+	static_assert(sizeof(InventoryUserUIInterface) == 0x80);
+}
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/I/InventoryInterface.h"
+
+namespace RE
+{
+	class InventoryUserUIInterfaceEntry
+	{
+	public:
+		// members
+		InventoryInterface::Handle     invHandle;   // 00
+		BSTSmallArray<std::uint8_t, 4> stackIndex;  // 08
+	};
+	static_assert(sizeof(InventoryUserUIInterfaceEntry) == 0x20);
+}
@@ -0,0 +1,43 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+#include "Scaleform/G/GFx_Value.h"
+
+namespace RE
+{
+	namespace InventoryUserUIUtils
+	{
+		namespace detail
+		{
+			inline void AddItemCardInfoEntry(
+				Scaleform::GFx::Value& a_array,
+				Scaleform::GFx::Value& a_newEntry,
+				const BSFixedStringCS& a_textID,
+				Scaleform::GFx::Value& a_value,
+				float                  a_difference = 0.0F,
+				float                  a_totalDamage = FLT_MAX,
+				float                  a_compareDamage = FLT_MAX)
+			{
+				using func_t = decltype(&detail::AddItemCardInfoEntry);
+				static REL::Relocation<func_t> func{ ID::InventoryUserUIUtils::AddItemCardInfoEntry };
+				return func(a_array, a_newEntry, a_textID, a_value, a_difference, a_totalDamage, a_compareDamage);
+			}
+		}
+
+		inline void AddItemCardInfoEntry(Scaleform::GFx::Value& a_array, Scaleform::GFx::Value& a_entry, const char* a_name, Scaleform::GFx::Value a_value, float a_difference, float a_totalValue = FLT_MAX, float a_comparisonValue = FLT_MAX)
+		{
+			detail::AddItemCardInfoEntry(a_array, a_entry, a_name, a_value, a_difference, a_totalValue, a_comparisonValue);
+		}
+
+		inline void AddItemCardInfoEntry(Scaleform::GFx::Value& a_array, Scaleform::GFx::Value& a_entry, const char* a_name = "", Scaleform::GFx::Value a_value = 0)
+		{
+			detail::AddItemCardInfoEntry(a_array, a_entry, a_name, a_value);
+		}
+
+		inline void AddItemCardInfoEntry(Scaleform::GFx::Value& a_array, const char* a_name, Scaleform::GFx::Value a_value)
+		{
+			Scaleform::GFx::Value entry;
+			detail::AddItemCardInfoEntry(a_array, entry, a_name, a_value);
+		}
+	}
+}
@@ -0,0 +1,13 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	class IsPipboyActiveEvent :
+		public BSTValueEvent<bool>  // 00
+	{
+	public:
+	};
+	static_assert(sizeof(IsPipboyActiveEvent) == 0x02);
+}
@@ -0,0 +1,38 @@
+#pragma once
+
+#include "RE/B/BSTEvent.h"
+
+namespace RE
+{
+	namespace ItemCrafted
+	{
+		class Event
+		{
+		public:
+			// members
+			const TESFurniture*           workbench;
+			const BGSConstructibleObject* recipe;
+		};
+
+		inline void NotifyOfItemCrafted(const TESFurniture* a_workbench, const BGSConstructibleObject* a_recipe)
+		{
+			using func_t = decltype(&NotifyOfItemCrafted);
+			static REL::Relocation<func_t> func{ ID::ItemCrafted::NotifyOfItemCrafted };
+			return func(a_workbench, a_recipe);
+		}
+
+		inline void RegisterSink(BSTEventSink<Event>* a_sink)
+		{
+			using func_t = decltype(&RegisterSink);
+			static REL::Relocation<func_t> func{ ID::ItemCrafted::RegisterSink };
+			return func(a_sink);
+		}
+
+		inline void UnregisterSink(BSTEventSink<Event>* a_sink)
+		{
+			using func_t = decltype(&UnregisterSink);
+			static REL::Relocation<func_t> func{ ID::ItemCrafted::UnregisterSink };
+			return func(a_sink);
+		}
+	}
+}