From 93a980657e69f73810a5f7ad60a4ae4b6da4588a Mon Sep 17 00:00:00 2001
From: shad0wshayd3 <shad0wshayd3@users.noreply.github.com>
Date: Sat, 5 Aug 2023 15:28:00 -0600
Subject: [PATCH] misc defs

---
 CommonLibF4/cmake/sourcelist.cmake            |   3 +
 CommonLibF4/include/RE/Bethesda/Actor.h       |  29 ++-
 CommonLibF4/include/RE/Bethesda/BSGraphics.h  |  96 +++++++++
 CommonLibF4/include/RE/Bethesda/IMenu.h       |   7 +
 .../include/RE/Bethesda/ImageSpaceData.h      |  54 ++++++
 .../include/RE/Bethesda/ImageSpaceEffect.h    | 182 ++++++++++++++++++
 .../include/RE/Bethesda/ImageSpaceManager.h   |  47 +++++
 .../include/RE/Bethesda/ImageSpaceModifier.h  |   9 +-
 .../include/RE/Bethesda/MenuControls.h        |   2 +-
 .../include/RE/Bethesda/PipboyManager.h       |  56 ++++++
 .../include/RE/Bethesda/PlayerCharacter.h     |  15 ++
 CommonLibF4/include/RE/Bethesda/TESForms.h    |  12 +-
 CommonLibF4/include/RE/Fallout.h              |   3 +
 13 files changed, 487 insertions(+), 28 deletions(-)
 create mode 100644 CommonLibF4/include/RE/Bethesda/ImageSpaceData.h
 create mode 100644 CommonLibF4/include/RE/Bethesda/ImageSpaceEffect.h
 create mode 100644 CommonLibF4/include/RE/Bethesda/ImageSpaceManager.h

diff --git a/CommonLibF4/cmake/sourcelist.cmake b/CommonLibF4/cmake/sourcelist.cmake
index a7aef057..067b52c6 100644
--- a/CommonLibF4/cmake/sourcelist.cmake
+++ b/CommonLibF4/cmake/sourcelist.cmake
@@ -163,6 +163,9 @@ set(SOURCES
 	include/RE/Bethesda/HUDModes.h
 	include/RE/Bethesda/IMenu.h
 	include/RE/Bethesda/IMovementInterface.h
+	include/RE/Bethesda/ImageSpaceData.h
+	include/RE/Bethesda/ImageSpaceEffect.h
+	include/RE/Bethesda/ImageSpaceManager.h
 	include/RE/Bethesda/ImageSpaceModifier.h
 	include/RE/Bethesda/InputDevice.h
 	include/RE/Bethesda/InputEvent.h
diff --git a/CommonLibF4/include/RE/Bethesda/Actor.h b/CommonLibF4/include/RE/Bethesda/Actor.h
index d6ad6d8e..90a0f889 100644
--- a/CommonLibF4/include/RE/Bethesda/Actor.h
+++ b/CommonLibF4/include/RE/Bethesda/Actor.h
@@ -115,14 +115,6 @@ namespace RE
 		struct PerkEntryUpdatedEvent;
 	}
 
-	enum class INTERACTING_STATE : std::uint32_t
-	{
-		kNotInteracting,
-		kWaitingToInteract,
-		kInteracting,
-		kWaitingToStopInteracting
-	};
-
 	enum class PTYPE : std::int32_t
 	{
 		kExplore = 0,
@@ -650,6 +642,19 @@ namespace RE
 	};
 	static_assert(sizeof(MagicTarget) == 0x18);
 
+	enum class LIFE_STATE : std::uint32_t
+	{
+		kAlive,
+		kDying,
+		kDead,
+		kUnconscious,
+		kReanimate,
+		kRecycle,
+		kRestrained,
+		kEssentialDown,
+		kBleedout
+	};
+
 	enum class WEAPON_STATE : std::uint32_t
 	{
 		kSheathed,
@@ -673,6 +678,14 @@ namespace RE
 		kFireSighted
 	};
 
+	enum class INTERACTING_STATE : std::uint32_t
+	{
+		kNotInteracting,
+		kWaitingToInteract,
+		kInteracting,
+		kWaitingToStopInteracting
+	};
+
 	class __declspec(novtable) ActorState :
 		public IMovementState  // 00
 	{
diff --git a/CommonLibF4/include/RE/Bethesda/BSGraphics.h b/CommonLibF4/include/RE/Bethesda/BSGraphics.h
index 80745031..35792567 100644
--- a/CommonLibF4/include/RE/Bethesda/BSGraphics.h
+++ b/CommonLibF4/include/RE/Bethesda/BSGraphics.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "RE/Bethesda/Atomic.h"
 #include "RE/Bethesda/BSTHashMap.h"
 #include "RE/NetImmerse/NiRect.h"
 #include "RE/NetImmerse/NiSmartPointer.h"
@@ -39,6 +40,7 @@ namespace RE
 
 	namespace BSGraphics
 	{
+		enum class Format;
 		enum class TextureAddressMode;
 
 		class RendererShadowState;
@@ -473,6 +475,100 @@ namespace RE
 			bool immediateTextureLoads;                                     // 3B1
 		};
 		static_assert(sizeof(State) == 0x3C0);
+
+		struct RenderTargetProperties
+		{
+		public:
+			// members
+			std::uint32_t width;          // 00
+			std::uint32_t height;         // 04
+			Format format;                // 08
+			std::uint32_t multiSample;    // 0C
+			bool copyable;                // 10
+			bool supportUnorderedAccess;  // 11
+			bool allowMipGeneration;      // 12
+			bool forceLinear;             // 13
+			std::int32_t mipLevel;        // 14
+			std::uint32_t textureTarget;  // 18
+			bool enableFastClear;         // 1C
+		};
+		static_assert(sizeof(RenderTargetProperties) == 0x20);
+
+		struct DepthStencilTargetProperties
+		{
+		public:
+			// members
+			std::uint32_t width;        // 00
+			std::uint32_t height;       // 04
+			std::uint32_t arraySize;    // 08
+			std::uint32_t multiSample;  // 0C
+			std::int32_t alias;         // 10
+			bool sampleable;            // 14
+			bool htile;                 // 15
+			bool stencil;               // 16
+			bool use16BitsDepth;        // 17
+		};
+		static_assert(sizeof(DepthStencilTargetProperties) == 0x18);
+
+		struct CubeMapRenderTargetProperties
+		{
+		public:
+			// members
+			std::uint32_t width;          // 00
+			std::uint32_t height;         // 04
+			Format format;                // 08
+			std::uint32_t multiSample;    // 0C
+			bool sampleable;              // 10
+			std::int32_t alias;           // 14
+			std::int32_t _360Alias;       // 18
+			std::int32_t _360Group;       // 1C
+			std::int32_t _360TileHeight;  // 20
+		};
+		static_assert(sizeof(CubeMapRenderTargetProperties) == 0x24);
+
+		class RenderTargetManager
+		{
+		public:
+			using Create_T = void(*)();
+
+			[[nodiscard]] static RenderTargetManager GetSingleton()
+			{
+				REL::Relocation<RenderTargetManager*> singleton{ REL::ID(1508457) };
+				return *singleton;
+			}
+
+			void SetEnableDynamicResolution(bool a_enableDynamicResolution)
+			{
+				using func_t = decltype(&RenderTargetManager::SetEnableDynamicResolution);
+				REL::Relocation<func_t> func{ REL::ID(116947) };
+				return func(this, a_enableDynamicResolution);
+			}
+
+			// members
+			RenderTargetProperties renderTargetData[100];              // 000
+			DepthStencilTargetProperties depthStencilTargetData[12];   // C80
+			CubeMapRenderTargetProperties cubeMapRenderTargetData[1];  // DA0
+			std::uint32_t renderTargetID[100];                         // DC4
+			std::uint32_t depthStencilTargetID[12];                    // F54
+			std::uint32_t cubeMapRenderTargetID[1];                    // F84
+			float dynamicWidthRatio;                                   // F88
+			float dynamicHeightRatio;                                  // F8C
+			float lowestWidthRatio;                                    // F90
+			float lowestHeightRatio;                                   // F94
+			float ratioIncreasePerSeconds;                             // F98
+			float ratioDecreasePerSeconds;                             // F9C
+			float movementDelta;                                       // FA0
+			bool increaseResolution;                                   // FA4
+			bool freezeResolution;                                     // FA5
+			bool updateResolutionOnlyWhenMoving;                       // FA6
+			bool useDynamicResolutionViewportAsDefaultViewport;        // FA7
+			bool isDynamicResolutionCurrentlyActivated;                // FA8
+			std::uint32_t nbFramePause;                                // FAC
+			std::uint32_t nbFramesSinceLastIncrease;                   // FB0
+			BSTAtomicValue<std::uint32_t> dynamicResolutionDisabled;   // FB4
+			Create_T create;                                           // FB8
+		};
+		static_assert(sizeof(RenderTargetManager) == 0xFC0);
 	};
 
 	namespace BSShaderTechniqueIDMap
diff --git a/CommonLibF4/include/RE/Bethesda/IMenu.h b/CommonLibF4/include/RE/Bethesda/IMenu.h
index 62e326fb..cdcd0558 100644
--- a/CommonLibF4/include/RE/Bethesda/IMenu.h
+++ b/CommonLibF4/include/RE/Bethesda/IMenu.h
@@ -895,6 +895,13 @@ namespace RE
 			return func(this);
 		}
 
+		void End3D()
+		{
+			using func_t = decltype(&Inventory3DManager::End3D);
+			REL::Relocation<func_t> func{ REL::ID(1512675) };
+			return func(this);
+		}
+
 		// members
 		bool useBoundForScale: 1;                                                // 010:0
 		bool startedZoomThisFrame: 1;                                            // 010:1
diff --git a/CommonLibF4/include/RE/Bethesda/ImageSpaceData.h b/CommonLibF4/include/RE/Bethesda/ImageSpaceData.h
new file mode 100644
index 00000000..2bb4f8f0
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/ImageSpaceData.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "RE/Bethesda/BSFixedString.h"
+#include "RE/NetImmerse/NiSmartPointer.h"
+#include "RE/NetImmerse/NiTexture.h"
+
+namespace RE
+{
+	namespace BSGraphics
+	{
+		class Texture;
+	}
+
+	struct ImageSpaceBaseData
+	{
+	public:
+		// members
+		float hdrData[9];        // 00
+		float cinematicData[3];  // 24
+		float tintData[4];       // 30
+		float dofData[6];        // 40
+	};
+	static_assert(sizeof(ImageSpaceBaseData) == 0x58);
+
+	struct 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);
+
+	struct ImageSpaceModData
+	{
+	public:
+		// members
+		float data[20];  // 00
+	};
+	static_assert(sizeof(ImageSpaceModData) == 0x50);
+
+	struct ImageSpaceData
+	{
+	public:
+		// members
+		ImageSpaceBaseData baseData;  //00
+		ImageSpaceModData modData;    //58
+		float highestTintAmount;      //A8
+		float highestFadeAmount;      //AC
+	};
+	static_assert(sizeof(ImageSpaceData) == 0xB0);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/ImageSpaceEffect.h b/CommonLibF4/include/RE/Bethesda/ImageSpaceEffect.h
new file mode 100644
index 00000000..d9bd9ed8
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/ImageSpaceEffect.h
@@ -0,0 +1,182 @@
+#pragma once
+
+#include "RE/NetImmerse/NiTArray.h"
+
+namespace RE
+{
+	namespace BSGraphics
+	{
+		enum class TextureAddressMode;
+		enum class TextureFilterMode;
+	}
+
+	class BSTriShape;
+	class ImageSpaceEffectParam;
+	class ImageSpaceManager;
+	class ImageSpaceTexture;
+	class NiTexture;
+
+	class ImageSpaceEffect
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffect };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffect };
+
+		struct 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);
+
+		struct 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);
+
+	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);
+
+	class ImageSpaceEffectFullScreenBlur :
+		public ImageSpaceEffect
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ImageSpaceEffectFullScreenBlur };
+		static constexpr auto VTABLE{ VTABLE::ImageSpaceEffectFullScreenBlur };
+
+		virtual ~ImageSpaceEffectFullScreenBlur();  // 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 REL::Relocation<bool*> bDisable{ REL::ID(372489) };
+
+		// members
+		ImageSpaceTexture buffer[3];  // B0
+	};
+	static_assert(sizeof(ImageSpaceEffectFullScreenBlur) == 0x128);
+
+	class ImageSpaceEffectGetHit:
+		public ImageSpaceEffect
+	{
+	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 REL::Relocation<bool*> bDisable{ REL::ID(1523708) };
+
+		// members
+		float* data;                  // B0
+		ImageSpaceTexture buffer[2];  // B8
+	};
+	static_assert(sizeof(ImageSpaceEffectGetHit) == 0x108);
+
+	class ImageSpaceEffectRadialBlur :
+		public ImageSpaceEffect
+	{
+	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 REL::Relocation<bool*> bDisable{ REL::ID(1500590) };
+	};
+	static_assert(sizeof(ImageSpaceEffectRadialBlur) == 0xB0);
+
+	class ImageSpaceEffectTemporalAA :
+		public ImageSpaceEffect
+	{
+	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 REL::Relocation<std::uint32_t*> MaskS{ REL::ID(775377) };
+
+		// members
+		float previousInvTexSizeX;         // B0
+		float previousInvTexSizeY;         // B4
+		float previousDynamicWidthRatio;   // B8
+		float previousDynamicHeightRatio;  // BC
+	};
+	static_assert(sizeof(ImageSpaceEffectTemporalAA) == 0xC0);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/ImageSpaceManager.h b/CommonLibF4/include/RE/Bethesda/ImageSpaceManager.h
new file mode 100644
index 00000000..f82b68ee
--- /dev/null
+++ b/CommonLibF4/include/RE/Bethesda/ImageSpaceManager.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include "RE/Bethesda/ImageSpaceData.h"
+#include "RE/NetImmerse/NiColor.h"
+#include "RE/NetImmerse/NiRect.h"
+#include "RE/NetImmerse/NiSmartPointer.h"
+
+namespace RE
+{
+	class BSTriShape;
+	class ImageSpaceEffect;
+
+	class ImageSpaceManager
+	{
+	public:
+		[[nodiscard]] static ImageSpaceManager* GetSingleton()
+		{
+			REL::Relocation<ImageSpaceManager**> singleton{ REL::ID(161743) };
+			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* paseData;               // 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);
+}
diff --git a/CommonLibF4/include/RE/Bethesda/ImageSpaceModifier.h b/CommonLibF4/include/RE/Bethesda/ImageSpaceModifier.h
index 1a7cb179..e7cf3f20 100644
--- a/CommonLibF4/include/RE/Bethesda/ImageSpaceModifier.h
+++ b/CommonLibF4/include/RE/Bethesda/ImageSpaceModifier.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "RE/Bethesda/BSFixedString.h"
+#include "RE/Bethesda/ImageSpaceData.h"
 #include "RE/NetImmerse/NiAVObject.h"
 #include "RE/NetImmerse/NiObject.h"
 #include "RE/NetImmerse/NiSmartPointer.h"
@@ -10,14 +11,6 @@ namespace RE
 	class TESImageSpaceModifier;
 	class TESImageSpaceModifierForm;
 
-	struct ImageSpaceModData
-	{
-	public:
-		// members
-		float data[20];  // 00
-	};
-	static_assert(sizeof(ImageSpaceModData) == 0x50);
-
 	class ImageSpaceModifierFinder
 	{
 	public:
diff --git a/CommonLibF4/include/RE/Bethesda/MenuControls.h b/CommonLibF4/include/RE/Bethesda/MenuControls.h
index e83eacf7..599380cd 100644
--- a/CommonLibF4/include/RE/Bethesda/MenuControls.h
+++ b/CommonLibF4/include/RE/Bethesda/MenuControls.h
@@ -7,13 +7,13 @@
 namespace RE
 {
 	class BSInputEventUser;
+	class PipboyHandler;
 
 	struct CameraZoomHandler;
 	struct ClickHandler;
 	struct DisconnectHandler;
 	struct GFxConvertHandler;
 	struct MenuOpenHandler;
-	struct PipboyHandler;
 	struct QuickSaveLoadHandler;
 	struct ScreenshotHandler;
 
diff --git a/CommonLibF4/include/RE/Bethesda/PipboyManager.h b/CommonLibF4/include/RE/Bethesda/PipboyManager.h
index a599b9c5..a81acf40 100644
--- a/CommonLibF4/include/RE/Bethesda/PipboyManager.h
+++ b/CommonLibF4/include/RE/Bethesda/PipboyManager.h
@@ -66,6 +66,13 @@ namespace RE
 			return *singleton;
 		}
 
+		void ClosedownPipboy()
+		{
+			using func_t = decltype(&PipboyManager::ClosedownPipboy);
+			REL::Relocation<func_t> func{ REL::ID(731410) };
+			return func(this);
+		}
+
 		void InitPipboy()
 		{
 			using func_t = decltype(&PipboyManager::InitPipboy);
@@ -87,6 +94,13 @@ namespace RE
 			return func(this);
 		}
 
+		void OnPipboyCloseAnimFailed()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyCloseAnimFailed);
+			REL::Relocation<func_t> func{ REL::ID(1362084) };
+			return func(this);
+		}
+
 		void OnPipboyClosed()
 		{
 			using func_t = decltype(&PipboyManager::OnPipboyClosed);
@@ -94,6 +108,20 @@ namespace RE
 			return func(this);
 		}
 
+		void OnPipboyOpenAnim()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyOpenAnim);
+			REL::Relocation<func_t> func{ REL::ID(1500318) };
+			return func(this);
+		}
+
+		void OnPipboyOpenAnimFailed()
+		{
+			using func_t = decltype(&PipboyManager::OnPipboyOpenAnimFailed);
+			REL::Relocation<func_t> func{ REL::ID(702357) };
+			return func(this);
+		}
+
 		void OnPipboyOpened()
 		{
 			using func_t = decltype(&PipboyManager::OnPipboyOpened);
@@ -108,6 +136,20 @@ namespace RE
 			return func(this, a_noAnim);
 		}
 
+		void PlayPipboyGenericOpenAnim(const BSFixedString& a_menu, const BSFixedString& a_anim, bool a_noAnim)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyGenericOpenAnim);
+			REL::Relocation<func_t> func{ REL::ID(809076) };
+			return func(this, a_menu, a_anim, a_noAnim);
+		}
+
+		void PlayPipboyLoadHolotapeAnim(BGSNote* a_holotape, bool a_noAnim)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyLoadHolotapeAnim);
+			REL::Relocation<func_t> func{ REL::ID(477096) };
+			return func(this, a_holotape, a_noAnim);
+		}
+
 		void PlayPipboyOpenAnim(const RE::BSFixedString& a_menuName)
 		{
 			using func_t = decltype(&PipboyManager::PlayPipboyOpenAnim);
@@ -115,6 +157,20 @@ namespace RE
 			return func(this, a_menuName);
 		}
 
+		void PlayPipboyTerminalAnim(BGSTerminal* a_terminal)
+		{
+			using func_t = decltype(&PipboyManager::PlayPipboyTerminalAnim);
+			REL::Relocation<func_t> func{ REL::ID(743427) };
+			return func(this, a_terminal);
+		}
+
+		void ProcessLoweringReason()
+		{
+			using func_t = decltype(&PipboyManager::ProcessLoweringReason);
+			REL::Relocation<func_t> func{ REL::ID(302903) };
+			return func(this);
+		}
+
 		bool QPipboyActive()
 		{
 			using func_t = decltype(&PipboyManager::QPipboyActive);
diff --git a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h
index aa5efd86..4751003f 100644
--- a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h
+++ b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h
@@ -22,6 +22,7 @@ namespace RE
 {
 	enum class COMMAND_TYPE;
 	enum class DEFAULT_OBJECT;
+	enum class DIFFICULTY_LEVEL;
 	enum class PLAYER_ACTION;
 	enum class QUEST_OBJECTIVE_STATE;
 	enum class SCENE_ACTION_PLAYER_RESPONSE_TYPE;
@@ -269,6 +270,13 @@ namespace RE
 			return *singleton;
 		}
 
+		DIFFICULTY_LEVEL GetDifficultyLevel()
+		{
+			using func_t = decltype(&PlayerCharacter::GetDifficultyLevel);
+			REL::Relocation<func_t> func{ REL::ID(922962) };
+			return func(this);
+		}
+
 		bool IsGodMode()
 		{
 			using func_t = decltype(&PlayerCharacter::IsGodMode);
@@ -343,6 +351,13 @@ namespace RE
 			return func(this, a_critCount);
 		}
 
+		void ShowPipboyLight(bool a_show, bool a_skipEffects)
+		{
+			using func_t = decltype(&PlayerCharacter::ShowPipboyLight);
+			REL::Relocation<func_t> func{ REL::ID(1304102) };
+			return func(this, a_show, a_skipEffects);
+		}
+
 		// members
 		BSSpinLock actorToDisplayOnHUDLock;                                                     // 628
 		BSSpinLock questTargetLock;                                                             // 630
diff --git a/CommonLibF4/include/RE/Bethesda/TESForms.h b/CommonLibF4/include/RE/Bethesda/TESForms.h
index b487d450..54a17c63 100644
--- a/CommonLibF4/include/RE/Bethesda/TESForms.h
+++ b/CommonLibF4/include/RE/Bethesda/TESForms.h
@@ -13,6 +13,7 @@
 #include "RE/Bethesda/BSTSmartPointer.h"
 #include "RE/Bethesda/BSTTuple.h"
 #include "RE/Bethesda/FormComponents.h"
+#include "RE/Bethesda/ImageSpaceData.h"
 #include "RE/Bethesda/Movement.h"
 #include "RE/Bethesda/Settings.h"
 #include "RE/Bethesda/TESCondition.h"
@@ -1827,17 +1828,6 @@ namespace RE
 	};
 	static_assert(sizeof(BGSDebris) == 0x38);
 
-	struct ImageSpaceBaseData
-	{
-	public:
-		// members
-		float hdrData[9];        // 00
-		float cinematicData[3];  // 24
-		float tintData[4];       // 30
-		float dofData[6];        // 40
-	};
-	static_assert(sizeof(ImageSpaceBaseData) == 0x58);
-
 	class __declspec(novtable) TESImageSpace :
 		public TESForm  // 00
 	{
diff --git a/CommonLibF4/include/RE/Fallout.h b/CommonLibF4/include/RE/Fallout.h
index 786c06ac..7e77b265 100644
--- a/CommonLibF4/include/RE/Fallout.h
+++ b/CommonLibF4/include/RE/Fallout.h
@@ -158,6 +158,9 @@
 #include "RE/Bethesda/HUDModes.h"
 #include "RE/Bethesda/IMenu.h"
 #include "RE/Bethesda/IMovementInterface.h"
+#include "RE/Bethesda/ImageSpaceData.h"
+#include "RE/Bethesda/ImageSpaceEffect.h"
+#include "RE/Bethesda/ImageSpaceManager.h"
 #include "RE/Bethesda/ImageSpaceModifier.h"
 #include "RE/Bethesda/InputDevice.h"
 #include "RE/Bethesda/InputEvent.h"