docs: add plugin setup guide

plugin/lib/commonlibf4/include/RE/E/EDGE_EXTRA_INFO_TYPE.h

@@ -0,0 +1,13 @@
+#pragma once
+
+namespace RE
+{
+	enum class EDGE_EXTRA_INFO_TYPE : std::int32_t
+	{
+		kInvalid = -1,
+		kPortal = 0x0,
+		kLedgeUp = 0x1,
+		kLedgeDown = 0x2,
+		kEnableDisablePortal = 0x3
+	};
+}

plugin/lib/commonlibf4/include/RE/E/ENCOUNTER_ZONE_DATA.h

@@ -0,0 +1,25 @@
+#pragma once
+
+namespace RE
+{
+	class ENCOUNTER_ZONE_DATA
+	{
+	public:
+		enum class FLAG
+		{
+			kNeverReset = 1u << 0,
+			kMatchPCBelowMin = 1u << 1,
+			kDisableCombatBoundary = 1u << 2,
+			kWorkshopZone = 1u << 3
+		};
+
+		// members
+		TESForm*                          zoneOwner;  // 00
+		BGSLocation*                      location;   // 08
+		std::int8_t                       ownerRank;  // 10
+		std::int8_t                       minLevel;   // 11
+		REX::TEnumSet<FLAG, std::uint8_t> flags;      // 12
+		std::int8_t                       maxLevel;   // 13
+	};
+	static_assert(sizeof(ENCOUNTER_ZONE_DATA) == 0x18);
+}

plugin/lib/commonlibf4/include/RE/E/ENCOUNTER_ZONE_GAME_DATA.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+	class ENCOUNTER_ZONE_GAME_DATA
+	{
+	public:
+		// members
+		std::uint32_t detachTime;  // 00
+		std::uint32_t attachTime;  // 04
+		std::uint32_t resetTime;   // 08
+		std::uint16_t zoneLevel;   // 0C
+	};
+	static_assert(sizeof(ENCOUNTER_ZONE_GAME_DATA) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/E/ENUM_COMPARISON_CONDITION.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	enum class ENUM_COMPARISON_CONDITION : std::int32_t
+	{
+		kEqual = 0x0,
+		kNotEqual = 0x1,
+		kGreaterThan = 0x2,
+		kGreaterThanEqual = 0x3,
+		kLessThan = 0x4,
+		kLessThanEqual = 0x5
+	};
+}

plugin/lib/commonlibf4/include/RE/E/ENUM_FORM_ID.h

@@ -0,0 +1,185 @@
+#pragma once
+
+namespace RE
+{
+	enum class ENUM_FORM_ID : std::int32_t
+	{
+		kNONE,  // 00 NONE X TESForm
+		//         X TESObject
+		//         X TESBoundObject
+		//         X MagicItem
+		//         X TESBoundAnimObject
+		//         X TESActorBase
+		//         X BGSStoryManagerTreeForm
+		//         X BGSStoryManagerNodeBase
+		kTES4,  // 01 TES4
+		kGRUP,  // 02 GRUP
+		kGMST,  // 03 GMST
+		kKYWD,  // 04 KYWD X BGSKeyword
+		kLCRT,  // 05 LCRT X BGSLocationRefType
+		kAACT,  // 06 AACT X BGSAction
+		kTRNS,  // 07 TRNS X BGSTransform
+		kCMPO,  // 08 CMPO X BGSComponent
+		kTXST,  // 09 TXST X BGSTextureSet
+		kMICN,  // 0A MICN X BGSMenuIcon
+		kGLOB,  // 0B GLOB X TESGlobal
+		kDMGT,  // 0C DMGT X BGSDamageType
+		kCLAS,  // 0D CLAS X TESClass
+		kFACT,  // 0E FACT X TESFaction
+		kHDPT,  // 0F HDPT X BGSHeadPart
+		kEYES,  // 10 EYES X TESEyes
+		kRACE,  // 11 RACE X TESRace
+		kSOUN,  // 12 SOUN X TESSound
+		kASPC,  // 13 ASPC X BGSAcousticSpace
+		kSKIL,  // 14 SKIL
+		kMGEF,  // 15 MGEF X EffectSetting
+		kSCPT,  // 16 SCPT X Script
+		kLTEX,  // 17 LTEX X TESLandTexture
+		kENCH,  // 18 ENCH X EnchantmentItem
+		kSPEL,  // 19 SPEL X SpellItem
+		kSCRL,  // 1A SCRL X ScrollItem
+		kACTI,  // 1B ACTI X TESObjectACTI
+		kTACT,  // 1C TACT X BGSTalkingActivator
+		kARMO,  // 1D ARMO X TESObjectARMO
+		kBOOK,  // 1E BOOK X TESObjectBOOK
+		kCONT,  // 1F CONT X TESObjectCONT
+		kDOOR,  // 20 DOOR X TESObjectDOOR
+		kINGR,  // 21 INGR X IngredientItem
+		kLIGH,  // 22 LIGH X TESObjectLIGH
+		kMISC,  // 23 MISC X TESObjectMISC
+		kSTAT,  // 24 STAT X TESObjectSTAT
+		kSCOL,  // 25 SCOL X BGSStaticCollection
+		kMSTT,  // 26 MSTT X BGSMovableStatic
+		kGRAS,  // 27 GRAS X TESGrass
+		kTREE,  // 28 TREE X TESObjectTREE
+		kFLOR,  // 29 FLOR X TESFlora
+		kFURN,  // 2A FURN X TESFurniture
+		kWEAP,  // 2B WEAP X TESObjectWEAP
+		kAMMO,  // 2C AMMO X TESAmmo
+		kNPC_,  // 2D NPC_ X TESNPC
+		kLVLN,  // 2E LVLN X TESLevCharacter
+		kKEYM,  // 2F KEYM X TESKey
+		kALCH,  // 30 ALCH X AlchemyItem
+		kIDLM,  // 31 IDLM X BGSIdleMarker
+		kNOTE,  // 32 NOTE X BGSNote
+		kPROJ,  // 33 PROJ X BGSProjectile
+		kHAZD,  // 34 HAZD X BGSHazard
+		kBNDS,  // 35 BNDS X BGSBendableSpline
+		kSLGM,  // 36 SLGM X TESSoulGem
+		kTERM,  // 37 TERM X BGSTerminal
+		kLVLI,  // 38 LVLI X TESLevItem
+		kWTHR,  // 39 WTHR X TESWeather
+		kCLMT,  // 3A CLMT X TESClimate
+		kSPGD,  // 3B SPGD X BGSShaderParticleGeometryData
+		kRFCT,  // 3C RFCT X BGSReferenceEffect
+		kREGN,  // 3D REGN X TESRegion
+		kNAVI,  // 3E NAVI X NavMeshInfoMap
+		kCELL,  // 3F CELL X TESObjectCELL
+		kREFR,  // 40 REFR X TESObjectREFR
+		//         X Explosion
+		//         X Projectile
+		kACHR,  // 41 ACHR X Actor
+		//         X PlayerCharacter
+		kPMIS,  // 42 PMIS X MissileProjectile
+		kPARW,  // 43 PARW X ArrowProjectile
+		kPGRE,  // 44 PGRE X GrenadeProjectile
+		kPBEA,  // 45 PBEA X BeamProjectile
+		kPFLA,  // 46 PFLA X FlameProjectile
+		kPCON,  // 47 PCON X ConeProjectile
+		kPBAR,  // 48 PBAR X BarrierProjectile
+		kPHZD,  // 49 PHZD X Hazard
+		kWRLD,  // 4A WRLD X TESWorldSpace
+		kLAND,  // 4B LAND X TESObjectLAND
+		kNAVM,  // 4C NAVM X NavMesh
+		kTLOD,  // 4D TLOD
+		kDIAL,  // 4E DIAL X TESTopic
+		kINFO,  // 4F INFO X TESTopicInfo
+		kQUST,  // 50 QUST X TESQuest
+		kIDLE,  // 51 IDLE X TESIdleForm
+		kPACK,  // 52 PACK X TESPackage
+		//         X AlarmPackage
+		//         X DialoguePackage
+		//         X FleePackage
+		//         X SpectatorPackage
+		//         X TrespassPackage
+		kCSTY,  // 53 CSTY X TESCombatStyle
+		kLSCR,  // 54 LSCR X TESLoadScreen
+		kLVSP,  // 55 LVSP X TESLevSpell
+		kANIO,  // 56 ANIO X TESObjectANIO
+		kWATR,  // 57 WATR X TESWaterForm
+		kEFSH,  // 58 EFSH X TESEffectShader
+		kTOFT,  // 59 TOFT
+		kEXPL,  // 5A EXPL X BGSExplosion
+		kDEBR,  // 5B DEBR X BGSDebris
+		kIMGS,  // 5C IMGS X TESImageSpace
+		kIMAD,  // 5D IMAD X TESImageSpaceModifier
+		kFLST,  // 5E FLST X BGSListForm
+		kPERK,  // 5F PERK X BGSPerk
+		kBPTD,  // 60 BPTD X BGSBodyPartData
+		kADDN,  // 61 ADDN X BGSAddonNode
+		kAVIF,  // 62 AVIF X ActorValueInfo
+		kCAMS,  // 63 CAMS X BGSCameraShot
+		kCPTH,  // 64 CPTH X BGSCameraPath
+		kVTYP,  // 65 VTYP X BGSVoiceType
+		kMATT,  // 66 MATT X BGSMaterialType
+		kIPCT,  // 67 IPCT X BGSImpactData
+		kIPDS,  // 68 IPDS X BGSImpactDataSet
+		kARMA,  // 69 ARMA X TESObjectARMA
+		kECZN,  // 6A ECZN X BGSEncounterZone
+		kLCTN,  // 6B LCTN X BGSLocation
+		kMESG,  // 6C MESG X BGSMessage
+		kRGDL,  // 6D RGDL
+		kDOBJ,  // 6E DOBJ X BGSDefaultObjectManager
+		kDFOB,  // 6F DFOB X BGSDefaultObject
+		kLGTM,  // 70 LGTM X BGSLightingTemplate
+		kMUSC,  // 71 MUSC X BGSMusicType
+		kFSTP,  // 72 FSTP X BGSFootstep
+		kFSTS,  // 73 FSTS X BGSFootstepSet
+		kSMBN,  // 74 SMBN X BGSStoryManagerBranchNode
+		kSMQN,  // 75 SMQN X BGSStoryManagerQuestNode
+		kSMEN,  // 76 SMEN X BGSStoryManagerEventNode
+		kDLBR,  // 77 DLBR X BGSDialogueBranch
+		kMUST,  // 78 MUST X BGSMusicTrackFormWrapper
+		kDLVW,  // 79 DLVW
+		kWOOP,  // 7A WOOP X TESWordOfPower
+		kSHOU,  // 7B SHOU X TESShout
+		kEQUP,  // 7C EQUP X BGSEquipSlot
+		kRELA,  // 7D RELA X BGSRelationship
+		kSCEN,  // 7E SCEN X BGSScene
+		kASTP,  // 7F ASTP X BGSAssociationType
+		kOTFT,  // 80 OTFT X BGSOutfit
+		kARTO,  // 81 ARTO X BGSArtObject
+		kMATO,  // 82 MATO X BGSMaterialObject
+		kMOVT,  // 83 MOVT X BGSMovementType
+		kSNDR,  // 84 SNDR X BGSSoundDescriptorForm
+		kDUAL,  // 85 DUAL X BGSDualCastData
+		kSNCT,  // 86 SNCT X BGSSoundCategory
+		kSOPM,  // 87 SOPM X BGSSoundOutput
+		kCOLL,  // 88 COLL X BGSCollisionLayer
+		kCLFM,  // 89 CLFM X BGSColorForm
+		kREVB,  // 8A REVB X BGSReverbParameters
+		kPKIN,  // 8B PKIN X BGSPackIn
+		kRFGP,  // 8C RFGP
+		kAMDL,  // 8D AMDL X BGSAimModel
+		kLAYR,  // 8E LAYR
+		kCOBJ,  // 8F COBJ X BGSConstructibleObject
+		kOMOD,  // 90 OMOD X BGSMod::Attachment::Mod
+		kMSWP,  // 91 MSWP X BGSMaterialSwap
+		kZOOM,  // 92 ZOOM X BGSZoomData
+		kINNR,  // 93 INNR X BGSInstanceNamingRules
+		kKSSM,  // 94 KSSM X BGSSoundKeywordMapping
+		kAECH,  // 95 AECH X BGSAudioEffectChain
+		kSCCO,  // 96 SCCO
+		kAORU,  // 97 AORU X BGSAttractionRule
+		kSCSN,  // 98 SCSN X BGSSoundCategorySnapshot
+		kSTAG,  // 99 STAG X BGSSoundTagSet
+		kNOCM,  // 9A NOCM
+		kLENS,  // 9B LENS X BGSLensFlare
+		kLSPR,  // 9C LSPR
+		kGDRY,  // 9D GDRY X BGSGodRays
+		kOVIS,  // 9E OVIS
+
+		kTotal,
+		kActiveEffect = 163
+	};
+}

plugin/lib/commonlibf4/include/RE/E/ENUM_LOD_MULT.h

@@ -0,0 +1,19 @@
+#pragma once
+
+namespace RE
+{
+	enum class ENUM_LOD_MULT : std::int32_t
+	{
+		kNone = 0x0,
+		kObjects = 0x1,
+		kItems = 0x2,
+		kActors = 0x3,
+		kTrees = 0x4,
+		kLandscape = 0x5,
+		kDistantLOD = 0x6,
+		kActorBodyPart = 0x7,
+		kRenderedMenu = 0x8,
+		kInvisible = 0x9,
+		kSkyCell = 0xA,
+	};
+}

plugin/lib/commonlibf4/include/RE/E/EQUIP_TYPE.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	enum class EQUIP_TYPE
+	{
+		kNone = 0x0,
+		kEquipped = 0x1,
+		kLeftHandEquip = 0x2,
+		kRightHandEquip = 0x3,
+		kBothHandEquip = 0x4,
+		kWillEquipAgain = 0x5
+	};
+}

plugin/lib/commonlibf4/include/RE/E/EXTERIOR_DATA.h

@@ -0,0 +1,30 @@
+#pragma once
+
+namespace RE
+{
+	class BGSTerrainVisibilityData;
+
+	class EXTERIOR_DATA
+	{
+	public:
+		enum class LandHideFlag : std::uint8_t
+		{
+			kNone = 0,
+			kQuad1 = 1 << 0,
+			kQuad2 = 1 << 1,
+			kQuad3 = 1 << 2,
+			kQuad4 = 1 << 3
+		};
+
+		// members
+		std::int32_t                cellX;          // 0x00
+		std::int32_t                cellY;          // 0x04
+		std::uint8_t*               maxHeightData;  // 0x08
+		BGSTerrainVisibilityData*   lodVisData;     // 0x10
+		float                       maxHeight;      // 0x18
+		float                       worldX;         // 0x1C
+		float                       worldY;         // 0x20
+		REX::TEnumSet<LandHideFlag> landHideFlags;  // 0x24
+	};
+	static_assert(sizeof(EXTERIOR_DATA) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/EXTRA_DATA_TYPE.h

@@ -0,0 +1,224 @@
+#pragma once
+
+namespace RE
+{
+	enum EXTRA_DATA_TYPE : std::int32_t
+	{
+		kNone,                          // BSExtraData
+		kHavok,                         //
+		kCell3D,                        //
+		kWaterType,                     // ExtraCellWaterType
+		kRegionList,                    //
+		kSeenData,                      //
+		kEditorID,                      // ExtraEditorID
+		kCellMusicType,                 //
+		kSkyRegion,                     //
+		kCellMidLowProcess,             //
+		kCellDetachTime,                //
+		kPersistentCell,                //
+		kKeywords,                      //
+		kAction,                        //
+		kStartingPosition,              //
+		kAnim,                          //
+		kHavokAnim,                     //
+		kBiped,                         //
+		kUsedMarkers,                   //
+		kDistantData,                   //
+		kRagdollData,                   // ExtraRagDollData
+		kCellPrevisRefs,                //
+		kInitActions,                   //
+		kEssentialProtected,            //
+		kPackagesStartLoc,              //
+		kPackage,                       //
+		kTresPassPackage,               // ExtraTresPassPackage
+		kRunOncePackages,               //
+		kReferenceHandle,               // ExtraReferenceHandles
+		kFollower,                      //
+		kLevCreaMod,                    //
+		kGhost,                         //
+		kOriginalReference,             //
+		kOwnership,                     //
+		kGlobal,                        //
+		kRank,                          //
+		kCount,                         //
+		kHealth,                        // ExtraHealth
+		kRangeDistOverride,             //
+		kTimeLeft,                      //
+		kCharge,                        //
+		kLight,                         // ExtraLight
+		kLock,                          // ExtraLock
+		kTeleport,                      // ExtraTeleport
+		kMapMarker,                     //
+		kLeveledCreature,               // ExtraLeveledCreature
+		kLevelItem,                     //
+		kScale,                         //
+		kSeed,                          //
+		kMagicCaster,                   //
+		kMagicTarget,                   //
+		kMasterFileCell,                //
+		kPlayerCrimeList,               //
+		kObjectInstance,                // BGSObjectInstanceExtra
+		kEnableStateParent,             //
+		kEnableStateChildren,           //
+		kItemDropper,                   //
+		kDroppedItemList,               //
+		kTeleportMarker,                //
+		kInactivePowerArmor,            //
+		kSavedHavokData,                //
+		kCannotWear,                    //
+		kPoison,                        //
+		kMagicLight,                    //
+		kLastFinishedSequence,          //
+		kSavedAnimation,                //
+		kNorthRotation,                 //
+		kSpawnCount,                    //
+		kFriendHits,                    //
+		kHeadTrackTarget,               //
+		kBoundArmor,                    //
+		kRefractionProperty,            //
+		kStartingWorldOrCell,           // ExtraStartingWorldOrCell
+		kFavorite,                      // ExtraFavorite
+		kEditorRef3DData,               //
+		kEditorRefMoveData,             //
+		kInfoGeneralTopic,              //
+		kNoRumors,                      //
+		kSound,                         //
+		kTerminalState,                 //
+		kLinkedRef,                     //
+		kLinkedRefChildren,             //
+		kActivateRef,                   //
+		kActivateRefChildren,           //
+		kTalkToPlayer,                  //
+		kObjectHealth,                  //
+		kImageSpace,                    //
+		kNavmeshPortal,                 //
+		kModelSwap,                     //
+		kRadius,                        //
+		kRadiation,                     //
+		kFactionChanges,                // ExtraFactionChanges
+		kDismemberedLimbs,              //
+		kActorCause,                    //
+		kMultibound,                    //
+		kMultiboundData,                //
+		kMultiboundRef,                 //
+		kReflectedRefs,                 //
+		kReflectorRefs,                 //
+		kEmittanceSource,               //
+		kRadioData,                     // ExtraRadioData
+		kCombatStyle,                   //
+		kLinkColorPair,                 //
+		kPrimitive,                     //
+		kOpenCloseActivateRef,          //
+		kAnimNoteReceiver,              //
+		kAmmo,                          // ExtraAmmo
+		kPatrolRefData,                 //
+		kPackageData,                   //
+		kOcclusionShape,                //
+		kCollisionData,                 //
+		kSayOnceADayTopicInfo,          //
+		kEncounterZone,                 //
+		kSayToTopicInfo,                //
+		kOcclusionPlaneRefData,         //
+		kPortalRefData,                 //
+		kPortal,                        //
+		kRoom,                          //
+		kGodRays,                       //
+		kRoomRefData,                   //
+		kGuardedRefData,                //
+		kCreatureAwakeSound,            //
+		kWaterZoneMap,                  //
+		kHorse,                         //
+		kIgnoredBySandbox,              //
+		kCellAcousticSpace,             //
+		kReservedMarkers,               //
+		kCellTransCount,                //
+		kWaterLightRefs,                //
+		kLitWaterRefs,                  //
+		kRadioRepeater,                 // ExtraRadioRepeater
+		kActivateLoopSound,             //
+		kPatrolRefInUseData,            //
+		kAshpileRef,                    //
+		kCreatureMovementSound,         //
+		kFollowerSwimBreadcrumbs,       //
+		kAliasInstanceArray,            // ExtraAliasInstanceArray
+		kLocation,                      // ExtraLocation
+		kMasterLocation,                //
+		kLocationRefType,               //
+		kPromotedRef,                   //
+		kAnimSequencer,                 //
+		kOutfitItem,                    //
+		kEditorLocation,                //
+		kLeveledItemBase,               //
+		kLightData,                     // ExtraLightData
+		kScene,                         //
+		kBadPosition,                   //
+		kHeadTrackingWeight,            //
+		kFromAlias,                     //
+		kShouldWear,                    //
+		kFavorCost,                     //
+		kAttachArrows3D,                //
+		kTextDisplayData,               // ExtraTextDisplayData
+		kAlphaCutoff,                   //
+		kEnchantment,                   //
+		kSoul,                          //
+		kForcedTarget,                  //
+		kSoundOutput,                   //
+		kUniqueID,                      // ExtraUniqueID
+		kFlags,                         //
+		kRefrPath,                      //
+		kDecalGroup,                    //
+		kLockList,                      //
+		kForcedLandingMarker,           //
+		kLargeRefOwnerCells,            //
+		kCellWaterEnvMap,               //
+		kCellGrassData,                 //
+		kTeleportName,                  //
+		kActorInteraction,              //
+		kWaterData,                     //
+		kWaterCurrentZoneData,          //
+		kAttachRef,                     //
+		kAttachRefChildren,             //
+		kGroupConstraint,               //
+		kScriptedAnimDependence,        //
+		kCachedScale,                   //
+		kRaceData,                      //
+		kGIDBuffer,                     //
+		kMissingRefIDs,                 //
+		kBendableSplineParams,          //
+		kReferenceGroup,                //
+		kLayer,                         //
+		kMovementController,            //
+		kReferenceCharacterController,  //
+		kMaterialSwap,                  // ExtraMaterialSwap
+		kInstanceData,                  // ExtraInstanceData
+		kPowerArmor,                    //
+		kAcousticParent,                //
+		kInputEnableLayer,              //
+		kProjectedDecalRef,             //
+		kWorkshop,                      // Workshop::ExtraData
+		kRadioReceiver,                 // ExtraRadioReceiver
+		kCulledBone,                    //
+		kActorValueStorage,             //
+		kDirectAtTarget,                //
+		kActivateText,                  //
+		kCellCombinedRefs,              //
+		kObjectBreakable,               //
+		kSavedDynamicIdles,             //
+		kIgnoredAttractKeywords,        //
+		kModRank,                       //
+		kInteriorLODWorldspace,         //
+		kActorBoneScaleMap,             //
+		kActorFXPickNodes,              //
+		kPowerArmorPreload,             //
+		kAnimGraphPreload,              //
+		kAnimSounds,                    //
+		kPowerLinks,                    // ExtraPowerLinks
+		kSavedUnrecoverableSubgraphs,   //
+		kRefWeaponSounds,               //
+		kRefInvestedGold,               //
+		kRefFurnitureEntryData,         //
+		kVoiceType,                     //
+
+		kTotal
+	};
+}

plugin/lib/commonlibf4/include/RE/E/EaseOutInterpolator.h

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

plugin/lib/commonlibf4/include/RE/E/EffectArchetypes.h

@@ -0,0 +1,62 @@
+#pragma once
+
+namespace RE
+{
+	namespace EffectArchetypes
+	{
+		enum class ArchetypeID : std::int32_t
+		{
+			kNone = -1,
+			kValueModifier = 0,
+			kScript = 1,
+			kDispel = 2,
+			kCureDisease = 3,
+			kAbsorb = 4,
+			kDualValueModifier = 5,
+			kCalm = 6,
+			kDemoralize = 7,
+			kFrenzy = 8,
+			kDisarm = 9,
+			kCommandSummoned = 10,
+			kInvisibility = 11,
+			kLight = 12,
+			kDarkness = 13,
+			kNightEye = 14,
+			kLock = 15,
+			kOpen = 16,
+			kBoundWeapon = 17,
+			kSummonCreature = 18,
+			kDetectLife = 19,
+			kTelekinesis = 20,
+			kParalyze = 21,
+			kReanimate = 22,
+			kSoulTrap = 23,
+			kTurnUndead = 24,
+			kGuide = 25,
+			kUnused01 = 26,
+			kCureParalysis = 27,
+			kCureAddiction = 28,
+			kCurePoison = 29,
+			kConcussion = 30,
+			kStimpak = 31,
+			kAccumulatingMagnitude = 32,
+			kStagger = 33,
+			kPeakValueModifier = 34,
+			kCloak = 35,
+			kUnused02 = 36,
+			kSlowTime = 37,
+			kRally = 38,
+			kEnhanceWeapon = 39,
+			kSpawnHazard = 40,
+			kEtherealize = 41,
+			kBanish = 42,
+			kSpawnScriptedRef = 43,
+			kDisguise = 44,
+			kDamage = 45,
+			kImmunity = 46,
+			kPermanentReanimate = 47,
+			kJetpack = 48,
+			kChameleon = 49,
+		};
+	}
+}

plugin/lib/commonlibf4/include/RE/E/EffectItem.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSStringT.h"
+#include "RE/E/EffectItemData.h"
+#include "RE/T/TESCondition.h"
+
+namespace RE
+{
+	class EffectItem
+	{
+	public:
+		void GetDescription(BSString* a_buffer, const char* a_beginTagFormat, const char* a_endTagFormat, float a_magnitude, float a_duration)
+		{
+			using func_t = decltype(&EffectItem::GetDescription);
+			static REL::Relocation<func_t> func{ ID::EffectItem::GetDescription };
+			return func(this, a_buffer, a_beginTagFormat, a_endTagFormat, a_magnitude, a_duration);
+		}
+
+		// members
+		EffectItemData data;           // 00
+		EffectSetting* effectSetting;  // 10
+		float          rawCost;        // 18
+		TESCondition   conditions;     // 20
+	};
+	static_assert(sizeof(EffectItem) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/EffectItemData.h

@@ -0,0 +1,14 @@
+#pragma once
+
+namespace RE
+{
+	class EffectItemData
+	{
+	public:
+		// members
+		float        magnitude;  // 0
+		std::int32_t area;       // 4
+		std::int32_t duration;   // 8
+	};
+	static_assert(sizeof(EffectItemData) == 0xC);
+}

plugin/lib/commonlibf4/include/RE/E/EffectSetting.h

@@ -0,0 +1,129 @@
+#pragma once
+
+#include "RE/B/BGSKeywordForm.h"
+#include "RE/B/BGSMenuDisplayObject.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/B/BSTArray.h"
+#include "RE/T/TESCondition.h"
+#include "RE/T/TESForm.h"
+#include "RE/T/TESFullName.h"
+
+namespace RE
+{
+	enum class SOUND_LEVEL;
+
+	namespace EffectArchetypes
+	{
+		enum class ArchetypeID;
+	}
+
+	namespace MagicSystem
+	{
+		enum class CastingType;
+		enum class Delivery;
+		enum class SoundID;
+	}
+
+	class __declspec(novtable) EffectSetting :
+		public TESForm,               // 000
+		public TESFullName,           // 020
+		public BGSMenuDisplayObject,  // 030
+		public BGSKeywordForm         // 040
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::EffectSetting };
+		static constexpr auto VTABLE{ VTABLE::EffectSetting };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kMGEF };
+
+		using FilterValidationFunction_t = bool(EffectSetting*, void*);
+
+		class EffectSettingData
+		{
+		public:
+			enum class Flag
+			{
+				kNone = 0,
+				kHostile = 1 << 0,
+				kRecover = 1 << 1,
+				kDetrimental = 1 << 2,
+				kSnapToNavMesh = 1 << 3,
+				kNoHitEvent = 1 << 4,
+				kDispelWithKeywords = 1 << 8,
+				kNoDuration = 1 << 9,
+				kNoMagnitude = 1 << 10,
+				kNoArea = 1 << 11,
+				kFXPersist = 1 << 12,
+				kGoryVisuals = 1 << 14,
+				kHideInUI = 1 << 15,
+				kNoRecast = 1 << 17,
+				kPowerAffectsMagnitude = 1 << 21,
+				kPowerAffectsDuration = 1 << 22,
+				kPainless = 1 << 26,
+				kNoHitEffect = 1 << 27,
+				kNoDeathDispel = 1 << 28
+			};
+
+			// members
+			REX::TEnumSet<Flag, std::uint32_t>                         flags;                  // 000
+			float                                                      baseCost;               // 004
+			TESForm*                                                   associatedForm;         // 008
+			ActorValueInfo*                                            associatedSkill;        // 010
+			ActorValueInfo*                                            resistVariable;         // 018
+			std::int16_t                                               numCounterEffects;      // 020
+			TESObjectLIGH*                                             light;                  // 028
+			float                                                      taperWeight;            // 030
+			TESEffectShader*                                           effectShader;           // 038
+			TESEffectShader*                                           enchantEffect;          // 040
+			std::int32_t                                               minimumSkill;           // 048
+			std::int32_t                                               spellmakingArea;        // 04C
+			float                                                      spellmakingChargeTime;  // 050
+			float                                                      taperCurve;             // 054
+			float                                                      taperDuration;          // 058
+			float                                                      secondaryAVWeight;      // 05C
+			REX::TEnumSet<EffectArchetypes::ArchetypeID, std::int32_t> archetype;              // 060
+			ActorValueInfo*                                            primaryAV;              // 068
+			BGSProjectile*                                             projectileBase;         // 070
+			BGSExplosion*                                              explosion;              // 078
+			REX::TEnumSet<MagicSystem::CastingType, std::int32_t>      castingType;            // 080
+			REX::TEnumSet<MagicSystem::Delivery, std::int32_t>         delivery;               // 084
+			ActorValueInfo*                                            secondaryAV;            // 088
+			BGSArtObject*                                              castingArt;             // 090
+			BGSArtObject*                                              hitEffectArt;           // 098
+			BGSImpactDataSet*                                          impactDataSet;          // 0A0
+			float                                                      skillUsageMult;         // 0A8
+			BGSDualCastData*                                           dualCastData;           // 0B0
+			float                                                      dualCastScale;          // 0B8
+			BGSArtObject*                                              enchantEffectArt;       // 0C0
+			BGSReferenceEffect*                                        hitVisuals;             // 0C8
+			BGSReferenceEffect*                                        enchantVisuals;         // 0D0
+			SpellItem*                                                 equipAbility;           // 0D8
+			TESImageSpaceModifier*                                     imageSpaceMod;          // 0E0
+			BGSPerk*                                                   perk;                   // 0E8
+			REX::TEnumSet<SOUND_LEVEL, std::int32_t>                   castingSoundLevel;      // 0F0
+			float                                                      aiScore;                // 0F4
+			float                                                      aiDelayTime;            // 0F8
+		};
+		static_assert(sizeof(EffectSettingData) == 0x100);
+
+		class SoundPair
+		{
+		public:
+			// members
+			REX::TEnumSet<MagicSystem::SoundID, std::int32_t> id;     // 00
+			BGSSoundDescriptorForm*                           sound;  // 08
+		};
+		static_assert(sizeof(SoundPair) == 0x10);
+
+		// members
+		FilterValidationFunction_t*        filterValidationFunction;   // 060
+		void*                              filterValidationItem;       // 068
+		EffectSettingData                  data;                       // 070
+		BSSimpleList<EffectSetting*>       counterEffects;             // 170
+		BSTArray<EffectSetting::SoundPair> effectSounds;               // 180
+		BGSLocalizedString                 magicItemDescription;       // 198
+		std::int32_t                       effectLoadedCount;          // 1A0
+		std::int32_t                       associatedItemLoadedCount;  // 1A4
+		TESCondition                       conditions;                 // 1A8
+	};
+	static_assert(sizeof(EffectSetting) == 0x1B0);
+}

plugin/lib/commonlibf4/include/RE/E/EffectShaderData.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "RE/D/_D3DBLEND.h"
+#include "RE/D/_D3DBLENDOP.h"
+#include "RE/D/_D3DCMPFUNC.h"
+
+namespace RE
+{
+	class EffectShaderData
+	{
+	public:
+		// members
+		REX::TEnumSet<_D3DBLEND, std::int32_t>   textureBlendModeSource;      // 00
+		REX::TEnumSet<_D3DBLENDOP, std::int32_t> textureBlendOperation;       // 04
+		REX::TEnumSet<_D3DCMPFUNC, std::int32_t> textureZTestFunction;        // 08
+		std::uint32_t                            fillColor1;                  // 0C
+		float                                    fillAlphaFadeInTime;         // 10
+		float                                    fillAlphaFullTime;           // 14
+		float                                    fillAlphaFadeOutTime;        // 18
+		float                                    fillAlphaPersistentPercent;  // 1C
+		float                                    fillAlphaPulseAmplitude;     // 20
+		float                                    fillAlphaPulseFrequency;     // 24
+		float                                    fillTextureUAnimSpeed;       // 28
+		float                                    fillTextureVAnimSpeed;       // 2C
+		float                                    edgeExponentValue;           // 30
+		std::uint32_t                            edgeColor;                   // 34
+		float                                    edgeAlphaFadeInTime;         // 38
+		float                                    edgeAlphaFullTime;           // 3C
+		float                                    edgeAlphaFadeOutTime;        // 40
+		float                                    edgeAlphaPersistentPercent;  // 44
+		float                                    edgeAlphaPulseAmplitude;     // 48
+		float                                    edgeAlphaPulseFrequency;     // 4C
+		float                                    fillAlphaFullPercent;        // 50
+		float                                    edgeAlphaFullPercent;        // 54
+		REX::TEnumSet<_D3DBLEND, std::int32_t>   textureBlendModeDest;        // 58
+		float                                    alphaTestStartTime;          // 5C
+		float                                    alphaTestEndTime;            // 60
+		float                                    alphaTestStartValue;         // 64
+		float                                    alphaTestEndValue;           // 68
+		BGSSoundDescriptorForm*                  ambientSound;                // 70
+		std::uint32_t                            fillColor2;                  // 78
+		std::uint32_t                            fillColor3;                  // 7C
+		float                                    fillColorScaleA[3];          // 80
+		float                                    fillColorTimeA[3];           // 8C
+		std::uint32_t                            flags;                       // 98
+		float                                    fillTextureUScale;           // 9C
+		float                                    fillTextureVScale;           // A0
+		std::int8_t                              boneDepth;                   // A4
+	};
+	static_assert(sizeof(EffectShaderData) == 0xA8);
+}

plugin/lib/commonlibf4/include/RE/E/EnchantmentItem.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "RE/M/MagicItem.h"
+
+namespace RE
+{
+	namespace MagicSystem
+	{
+		enum class CastingType;
+		enum class Delivery;
+		enum class SpellType;
+	}
+
+	class __declspec(novtable) EnchantmentItem :
+		public MagicItem  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::EnchantmentItem };
+		static constexpr auto VTABLE{ VTABLE::EnchantmentItem };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kENCH };
+
+		class Data :
+			public MagicItem::Data  // 00
+		{
+		public:
+			// members
+			REX::TEnumSet<MagicSystem::CastingType, std::int32_t> castingType;       // 08
+			std::int32_t                                          chargeOverride;    // 0C
+			REX::TEnumSet<MagicSystem::Delivery, std::int32_t>    delivery;          // 10
+			REX::TEnumSet<MagicSystem::SpellType, std::int32_t>   spellType;         // 14
+			float                                                 chargeTime;        // 18
+			EnchantmentItem*                                      baseEnchantment;   // 20
+			BGSListForm*                                          wornRestrictions;  // 28
+		};
+		static_assert(sizeof(Data) == 0x30);
+
+		// members
+		Data data;  // 0D0
+	};
+	static_assert(sizeof(EnchantmentItem) == 0x100);
+}

plugin/lib/commonlibf4/include/RE/E/EquipSlotData.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class EquipSlotData
+	{
+	public:
+		// members
+		BGSEquipSlot* equipSlot;      // 00
+		BSFixedString equipSlotNode;  // 08
+	};
+	static_assert(sizeof(EquipSlotData) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/E/EquippedItem.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/B/BGSEquipIndex.h"
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class EquippedItemData;
+
+	class EquippedItem
+	{
+	public:
+		// members
+		BGSObjectInstance           item;        // 00
+		const BGSEquipSlot*         equipSlot;   // 10
+		BGSEquipIndex               equipIndex;  // 18
+		NiPointer<EquippedItemData> data;        // 20
+	};
+	static_assert(sizeof(EquippedItem) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/EquippedItemData.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/E/EquippedItem.h"
+#include "RE/N/NiRefObject.h"
+
+namespace RE
+{
+	class BGSLoadFormBuffer;
+	class BGSSaveFormBuffer;
+
+	class __declspec(novtable) EquippedItemData :
+		public NiRefObject  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::EquippedItemData };
+		static constexpr auto VTABLE{ VTABLE::EquippedItemData };
+
+		// add
+		virtual void          SaveGame(BGSSaveFormBuffer* a_saveGameBuffer, const EquippedItem& a_equippedItem) const = 0;  // 02
+		virtual void          LoadGame(BGSLoadFormBuffer* a_loadGameBuffer, const EquippedItem& a_equippedItem) = 0;        // 03
+		virtual std::uint32_t GetObjectType() const = 0;                                                                    // 04
+	};
+	static_assert(sizeof(EquippedItemData) == 0x10);
+}

plugin/lib/commonlibf4/include/RE/E/EquippedWeaponData.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTTuple.h"
+#include "RE/E/EquippedItemData.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	enum class ATTACK_STATE_ENUM;
+	class AimModel;
+	class BSCloneReserver;
+	class MuzzleFlash;
+	class NiAVObject;
+	class QueuedFile;
+
+	class __declspec(novtable) EquippedWeaponData :
+		public EquippedItemData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::EquippedWeaponData };
+		static constexpr auto VTABLE{ VTABLE::EquippedWeaponData };
+
+		void SetupFireSounds(Actor& a_actor, BGSObjectInstanceT<TESObjectWEAP>& a_weapon)
+		{
+			using func_t = decltype(&EquippedWeaponData::SetupFireSounds);
+			static REL::Relocation<func_t> func{ ID::EquippedWeaponData::SetupFireSounds };
+			return func(this, a_actor, a_weapon);
+		}
+
+		// members
+		TESAmmo*                                 ammo;                     // 10
+		std::uint32_t                            ammoCount;                // 18
+		AimModel*                                aimModel;                 // 20
+		MuzzleFlash*                             muzzleFlash;              // 28
+		NiAVObject*                              fireNode;                 // 30
+		ATTACK_STATE_ENUM                        attackState;              // 38
+		BSTArray<BSTTuple<std::uint32_t, void*>> fireLocations;            // 40 - AnimationStanceFireLocationData<NiPoint3>
+		NiPointer<QueuedFile>                    weaponPreload;            // 58
+		NiPointer<QueuedFile>                    projectilePreload;        // 60
+		NiPointer<BSCloneReserver>               reserveProjectileClones;  // 68
+		BSSoundHandle                            idleSound;                // 70
+		BSSoundHandle                            attackSound;              // 78
+		BSSoundHandle                            reverbSound;              // 80
+		BSSoundHandle                            prevAttack;               // 88
+		BSSoundHandle                            prevReverb;               // 90
+		const BGSSoundKeywordMapping*            attackSoundData;          // 98
+		bool                                     reverbSoundIsTail;        // A0
+	};
+	static_assert(sizeof(EquippedWeaponData) == 0xA8);
+}

plugin/lib/commonlibf4/include/RE/E/ExamineConfirmMenu.h

@@ -0,0 +1,133 @@
+#pragma once
+
+#include "RE/B/BGSTypedFormValuePair.h"
+#include "RE/B/BSTHashMap.h"
+#include "RE/B/BSTTuple.h"
+#include "RE/G/GameMenuBase.h"
+#include "RE/S/Setting.h"
+
+namespace RE
+{
+	class ExamineMenu;
+
+	class __declspec(novtable) ExamineConfirmMenu :
+		public GameMenuBase  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExamineConfirmMenu };
+		static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu };
+		static constexpr auto MENU_NAME{ "ExamineConfirmMenu"sv };
+
+		enum class CONFIRM_TYPE
+		{
+			kSimple = 0,
+			kBuild = 1,
+			kScrap = 2,
+			kRepairFailure = 3
+		};
+
+		class __declspec(novtable) ICallback
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::ExamineConfirmMenu__ICallback };
+			static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu__ICallback };
+
+			ICallback(ExamineMenu* a_thisMenu) :
+				thisMenu(a_thisMenu)
+			{
+				REX::EMPLACE_VTABLE(this);
+			}
+
+			virtual ~ICallback() = default;  // 00
+
+			// add
+			virtual void OnAccept();  // 01
+
+			F4_HEAP_REDEFINE_NEW(ICallback);
+
+			// members
+			ExamineMenu* thisMenu;  // 08
+		};
+		static_assert(sizeof(ICallback) == 0x10);
+
+		class __declspec(novtable) InitData
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::ExamineConfirmMenu__InitData };
+			static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu__InitData };
+
+			InitData(BSFixedString a_confirmQuestion, BSFixedStringCS a_buttonLabel, CONFIRM_TYPE a_confirmType) :
+				confirmQuestion(a_confirmQuestion),
+				buttonLabel(a_buttonLabel),
+				confirmType(a_confirmType)
+			{
+				REX::EMPLACE_VTABLE(this);
+			}
+
+			virtual ~InitData() = default;  // 00
+
+			F4_HEAP_REDEFINE_NEW(InitData);
+
+			// members
+			BSFixedString                             confirmQuestion;                       // 08
+			BSFixedStringCS                           buttonLabel;                           // 10
+			REX::TEnumSet<CONFIRM_TYPE, std::int32_t> confirmType{ CONFIRM_TYPE::kSimple };  // 18
+			bool                                      hasCancelButton{ true };               // 1C
+		};
+		static_assert(sizeof(InitData) == 0x20);
+
+		class __declspec(novtable) InitDataScrap :
+			public InitData  // 00
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::ExamineConfirmMenu__InitDataScrap };
+			static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu__InitDataScrap };
+
+			InitDataScrap(const char* a_confirmQuestion, const char* a_buttonLabel, const char* a_scrapSourceName, BSTArray<BSTTuple<TESBoundObject*, std::uint32_t>> a_scrapResults) :
+				InitData(a_confirmQuestion, a_buttonLabel, CONFIRM_TYPE::kScrap),
+				scrapSourceName(a_scrapSourceName),
+				scrapResults(a_scrapResults)
+			{
+				REX::EMPLACE_VTABLE(this);
+			}
+
+			virtual ~InitDataScrap() = default;  // 00
+
+			F4_HEAP_REDEFINE_NEW(InitDataScrap);
+
+			// members
+			BSFixedStringCS                                    scrapSourceName;  // 20
+			BSTArray<BSTTuple<TESBoundObject*, std::uint32_t>> scrapResults;     // 28
+		};
+		static_assert(sizeof(InitDataScrap) == 0x40);
+
+		class __declspec(novtable) InitDataRepairFailure :
+			public InitData  // 00
+		{
+		public:
+			static constexpr auto RTTI{ RTTI::ExamineConfirmMenu__InitDataRepairFailure };
+			static constexpr auto VTABLE{ VTABLE::ExamineConfirmMenu__InitDataRepairFailure };
+
+			InitDataRepairFailure(const BSTArray<BSTTuple<TESForm*, BGSTypedFormValuePair::SharedVal>>* a_requiredItems) :
+				InitData(GameSettingCollection::GetSingleton()->GetSetting("sCannotRepairMessage")->GetString(), "$OK", CONFIRM_TYPE::kRepairFailure),
+				requiredItems(a_requiredItems)
+			{
+				this->hasCancelButton = false;
+				REX::EMPLACE_VTABLE(this);
+			}
+
+			virtual ~InitDataRepairFailure() = default;  // 00
+
+			F4_HEAP_REDEFINE_NEW(InitDataRepairFailure);
+
+			// members
+			const BSTArray<BSTTuple<TESForm*, BGSTypedFormValuePair::SharedVal>>* requiredItems;        // 20
+			BSTHashMap<TESBoundObject*, std::uint32_t>                            availableComponents;  // 28
+		};
+		static_assert(sizeof(InitDataRepairFailure) == 0x58);
+
+		// members
+		Scaleform::GFx::Value confirmObj;  // E0
+	};
+	static_assert(sizeof(ExamineConfirmMenu) == 0x100);
+}

plugin/lib/commonlibf4/include/RE/E/ExamineMenu.h

@@ -0,0 +1,177 @@
+#pragma once
+
+#include "RE/E/ExamineConfirmMenu.h"
+#include "RE/I/InventoryUserUIInterface.h"
+#include "RE/W/WorkbenchMenuBase.h"
+
+namespace RE
+{
+	enum class EQUIP_TYPE;
+	class BGSObjectInstanceExtra;
+	class BSInputEnableLayer;
+	class NiAVObject;
+
+	class __declspec(novtable) ExamineMenu :
+		public WorkbenchMenuBase  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExamineMenu };
+		static constexpr auto VTABLE{ VTABLE::ExamineMenu };
+		static constexpr auto MENU_NAME{ "ExamineMenu"sv };
+
+		enum class INSPECT_MODE_STATE
+		{
+			kModSlotSelect = 0,
+			kSelectNewMod = 1,
+			kInvComponentSelect = 2,
+			kItemSelect = 3,
+			kConfirm = 4
+		};
+
+		class ComponentBuilderFunctor
+		{
+		public:
+			// members
+			BSTArray<BSTTuple<BGSComponent*, std::uint8_t>> components;  // 00
+			TESObjectMISC*                                  a_object;    // 18
+			std::uint32_t                                   a_index;     // 20
+		};
+		static_assert(sizeof(ComponentBuilderFunctor) == 0x28);
+
+		virtual ~ExamineMenu();  // 00
+
+		// override (WorkbenchMenuBase)
+		virtual void               Call(const Params&) override;                                    // 01
+		virtual void               MapCodeObjectFunctions() override;                               // 02
+		virtual UI_MESSAGE_RESULTS ProcessMessage(UIMessage& a_message) override;                   // 03
+		virtual void               AdvanceMovie(float a_timeDelta, std::uint64_t a_time) override;  // 04
+		virtual void               OnHideMenu() override;                                           // 14
+		virtual void               BuildConfirmed(bool a_ownerIsWorkbench) override;                // 17
+		virtual bool               TryCreate() override;                                            // 1B
+
+		// override (BSInputEventUser)
+		virtual bool ShouldHandleEvent(const InputEvent*) override;       // 01
+		virtual void OnThumbstickEvent(const ThumbstickEvent*) override;  // 04
+		virtual void OnCursorMoveEvent(const CursorMoveEvent*) override;  // 05
+		virtual void OnButtonEvent(const ButtonEvent*) override;          // 08
+
+		// add
+		virtual EQUIP_TYPE              GetInventoryEntryEquipState(const InventoryUserUIInterfaceEntry& a_entry);                                                          // 1C
+		virtual void                    ShowCurrent3D();                                                                                                                    // 1D
+		virtual TESBoundObject*         GetCurrentObj();                                                                                                                    // 1E
+		virtual void                    FindWeaponMods(TESBoundObject* a_object, Scaleform::GFx::Value& a_modList);                                                         // 1F
+		virtual void                    BuildPossibleModList(TESBoundObject* a_object);                                                                                     // 20
+		virtual void                    SwitchMod(std::int32_t a_index, Scaleform::GFx::Value& a_entryList);                                                                // 21
+		virtual void                    NextItemPart();                                                                                                                     // 22
+		virtual void                    PreviousItemPart();                                                                                                                 // 23
+		virtual void                    AttachModToPreview(bool a_storeModelPosition);                                                                                      // 24
+		virtual BGSObjectInstanceExtra* GetInitialObjectInstanceExtra();                                                                                                    // 25
+		virtual BGSObjectInstanceExtra* GetObjectInstanceExtra();                                                                                                           // 26
+		virtual const ExtraDataList*    GetItemExtraDataList();                                                                                                             // 27
+		virtual void                    HighlightWeaponPart();                                                                                                              // 28
+		virtual void                    ResetHighlight();                                                                                                                   // 29
+		virtual void                    CreateModdedInventoryItem();                                                                                                        // 2A
+		virtual void                    RevertToInventoryItem();                                                                                                            // 2B
+		virtual const char*             GetCurrentName();                                                                                                                   // 2C
+		virtual void                    RenameCurrent(const char* a_newName);                                                                                               // 2D
+		virtual void                    UpdateItemCard(bool a_compare);                                                                                                     // 2E
+		virtual void                    UpdateItemList(std::int32_t a_indexToSelect);                                                                                       // 2F
+		virtual const char*             GetBuildConfirmButtonLabel();                                                                                                       // 30
+		virtual void                    GetBuildConfirmQuestion(char* a_buffer, std::uint32_t a_bufferLength);                                                              // 31
+		virtual bool                    GetCanRepairSelectedItem();                                                                                                         // 32
+		virtual NiAVObject*             GetCurrent3D();                                                                                                                     // 33
+		virtual bool                    GetCurrent3DLoaded();                                                                                                               // 34
+		virtual bool                    GetIsValidInventoryItem(const BGSInventoryItem& a_item, std::uint32_t a_stackID);                                                   // 35
+		virtual const char*             GetMenuName();                                                                                                                      // 36
+		virtual void                    OnSwitchBaseItem();                                                                                                                 // 37
+		virtual void                    PopulateInventoryItemObj(ObjectRefHandle a_owner, const InventoryUserUIInterfaceEntry& a_entry, Scaleform::GFx::Value& a_itemObj);  // 38
+		virtual void                    RegisterMenuComponents(const Scaleform::GFx::FunctionHandler::Params& a_params);                                                    // 39
+		virtual void                    RepairSelectedItem();                                                                                                               // 3A
+		virtual void                    SetFilter();                                                                                                                        // 3B
+		virtual void                    SetMouseRotation(bool a_rotation);                                                                                                  // 3C
+		virtual void                    ToggleItemEquipped();                                                                                                               // 3D
+		virtual void                    UpdateModSlotList();                                                                                                                // 3E
+		virtual void                    UpdateModChoiceList();                                                                                                              // 3F
+		virtual const char*             GetRankSuffix(std::uint32_t a_rank);                                                                                                // 40
+		virtual bool                    QIgnoreRank();                                                                                                                      // 41
+		virtual bool                    ShouldInitToFirstMod();                                                                                                             // 42
+		virtual void                    SetDataForConditionCheck();                                                                                                         // 43
+		virtual bool                    AddLooseModToModChoiceArray(BGSMod::Attachment::Mod* a_mod, std::uint8_t a_rank);                                                   // 44
+		virtual bool                    ShouldShowModSlot(const BGSKeyword* a_keyword);                                                                                     // 45
+
+		void BuildWeaponScrappingArray()
+		{
+			using func_t = decltype(&ExamineMenu::BuildWeaponScrappingArray);
+			static REL::Relocation<func_t> func{ ID::ExamineMenu::BuildWeaponScrappingArray };
+			return func(this);
+		}
+
+		[[nodiscard]] std::uint32_t GetSelectedIndex()
+		{
+			using func_t = decltype(&ExamineMenu::GetSelectedIndex);
+			static REL::Relocation<func_t> func{ ID::ExamineMenu::GetSelectedIndex };
+			return func(this);
+		}
+
+		void ShowConfirmMenu(ExamineConfirmMenu::InitData* a_data, ExamineConfirmMenu::ICallback* a_callback)
+		{
+			using func_t = decltype(&ExamineMenu::ShowConfirmMenu);
+			static REL::Relocation<func_t> func{ ID::ExamineMenu::ShowConfirmMenu };
+			return func(this, a_data, a_callback);
+		}
+
+		void ConsumeSelectedItems(bool a_autoBuild, const BGSSoundDescriptorForm* a_consumeSound)
+		{
+			using func_t = decltype(&ExamineMenu::ConsumeSelectedItems);
+			static REL::Relocation<func_t> func{ ID::ExamineMenu::ConsumeSelectedItems };
+			return func(this, a_autoBuild, a_consumeSound);
+		}
+
+		// members
+		ComponentBuilderFunctor                            componentFunctor;                    // 340
+		REX::TEnumSet<INSPECT_MODE_STATE, std::uint32_t>   inspectModeState;                    // 368
+		ObjectRefHandle                                    inventorySource;                     // 36C
+		InventoryUserUIInterface                           invInterface;                        // 370
+		InventoryInterface::Handle                         modItem;                             // 3F0
+		std::uint32_t                                      modStack;                            // 3F4
+		BSTHashMap<std::uint32_t, std::uint32_t>           scrappableItemsMap;                  // 3F8
+		BSTArray<BSTTuple<TESBoundObject*, std::uint32_t>> scrappingArray;                      // 420
+		BSTArray<BSTTuple<NiAVObject*, BGSKeyword const*>> slotObjects;                         // 440
+		BSTSmartPointer<ExtraDataList>                     extraDataList;                       // 458
+		std::uint32_t                                      slotObjectIndex;                     // 460
+		Scaleform::GFx::Value                              buttonAnimBase;                      // 468
+		Scaleform::GFx::Value                              itemList;                            // 488
+		Scaleform::GFx::Value                              itemNameTextField;                   // 4A8
+		Scaleform::GFx::Value                              itemInfoList;                        // 4C8
+		Scaleform::GFx::Value                              modChoiceList;                       // 4E8
+		Scaleform::GFx::Value                              modSlotList;                         // 508
+		Scaleform::GFx::Value                              currentModsList;                     // 528
+		BGSInventoryItem                                   moddedInventoryItem;                 // 548
+		bool                                               queueItemHighlight;                  // 558
+		float                                              zoomDistance;                        // 55C
+		float                                              lastFrameDelta;                      // 560
+		float                                              menuCursorLeftPct;                   // 564
+		float                                              menuCursorRightPct;                  // 568
+		float                                              menuCursorTopPct;                    // 56C
+		float                                              menuCursorBottomPct;                 // 570
+		BSTArray<BGSComponent*>                            queuedSoundArray;                    // 578
+		std::byte                                          attachPointSource3D[0x598 - 0x590];  // 590 - TODO
+		const BGSMod::Attachment::Mod*                     nullMod;                             // 598
+		Scaleform::GFx::Value                              requirementsList;                    // 5A0
+		Scaleform::GFx::Value                              itemSelectList;                      // 5C0
+		const BGSKeyword*                                  keyword;                             // 5E0
+		bool                                               queueChangeCameraPosition;           // 5E8
+		bool                                               returnToInspect;                     // 5E9
+		bool                                               highlightStoredItem;                 // 5EA
+		bool                                               textEntry;                           // 5EB
+		bool                                               virtualKeyboardPendingEvt;           // 5EC
+		bool                                               inspectMode;                         // 5ED
+		bool                                               inspectingSingleItem;                // 5EE
+		bool                                               inspectingFeaturedItem;              // 5EF
+		bool                                               showFeaturedItemMessage;             // 5F0
+		char                                               renameItemTo[260];                   // 5F1
+		char                                               renameItemCancelState[260];          // 6F5
+		BSTSmartPointer<BSInputEnableLayer>                inputLayer;                          // 800
+	};
+	static_assert(sizeof(ExamineMenu) == 0x810);
+}

plugin/lib/commonlibf4/include/RE/E/Explosion.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "RE/B/BGSBodyPartDefs.h"
+#include "RE/B/BGSObjectInstance.h"
+#include "RE/B/BSPointerHandle.h"
+#include "RE/B/BSSimpleList.h"
+#include "RE/B/BSSoundHandle.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/H/hknpClosestUniqueBodyIdHitCollector.h"
+#include "RE/N/NiPoint3.h"
+#include "RE/N/NiPointer.h"
+#include "RE/T/TESObjectREFR.h"
+
+namespace RE
+{
+	class ActorCause;
+	class NiLight;
+	class NonActorMagicCaster;
+
+	class __declspec(novtable) Explosion :
+		public TESObjectREFR  // 000
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::Explosion };
+		static constexpr auto VTABLE{ VTABLE::Explosion };
+		static constexpr auto FORM_ID{ ENUM_FORM_ID::kREFR };
+
+		enum class Flags
+		{
+			kDecalsPlaced = 0x1,
+			kTargetsFound = 0x2,
+			kTargetsProcessed = 0x4,
+			kForcesApplied = 0x8,
+			kIgnoreIsSwap = 0x10,
+			kUnderwater = 0x20,
+			kInitialized = 0x40,
+			kNonHostile = 0x80,
+			kWaterTestDone = 0x100,
+			kSoundTestDone = 0x200
+		};
+
+		class ExplodedLimb
+		{
+		public:
+			// members
+			REX::TEnumSet<BGSBodyPartDefs::LIMB_ENUM, std::int32_t> limb;           // 00
+			ActorValueInfo*                                         limbCondition;  // 08
+			float                                                   distance;       // 10
+		};
+		static_assert(sizeof(ExplodedLimb) == 0x18);
+
+		class ExplosionTarget
+		{
+		public:
+			enum class Flags
+			{
+				kHitWeakPoint = 0x1,
+				kMobile = 0x2,
+				kProcessed = 0x4,
+				kProcessedLimbs = 0x8
+			};
+
+			// members
+			ObjectRefHandle                     ref;                     // 00
+			REX::TEnumSet<Flags, std::uint32_t> flags;                   // 04
+			float                               hitFromExplosionSqrLen;  // 08
+			BSTArray<ExplodedLimb>              limbArray;               // 10
+		};
+		static_assert(sizeof(ExplosionTarget) == 0x28);
+
+		// add
+		virtual void Initialize();           // C6
+		virtual void Update(float a_delta);  // C7
+		virtual void FindTargets();          // C8
+
+		// members
+		hknpClosestUniqueBodyIdHitCollector collector;           // 110
+		void*                               explosionDBHandle;   // 520 - TODO
+		float                               age;                 // 528
+		float                               obj3Dlifetime;       // 52C
+		float                               audioLifetime;       // 530
+		float                               buildTime;           // 534
+		float                               innerRadius;         // 538
+		float                               outerRadius;         // 53C
+		float                               imageSpaceRadius;    // 540
+		float                               damageMult;          // 544
+		BSSimpleList<ExplosionTarget*>      targetList;          // 548
+		BSTSmallArray<BSSoundHandle, 4>     soundHandles;        // 558
+		NiPointer<NiLight>                  light;               // 588
+		ObjectRefHandle                     owner;               // 590
+		ObjectRefHandle                     explodedRef;         // 594
+		ObjectRefHandle                     createdRef;          // 598
+		BSTSmartPointer<ActorCause>         actorCause;          // 5A0
+		NonActorMagicCaster*                caster;              // 5A8
+		BGSObjectInstanceT<TESObjectWEAP>   weaponSource;        // 5B0
+		std::int32_t                        frameCount;          // 5C0
+		NiPoint3A                           closestPoint;        // 5D0
+		NiPoint3A                           closestPointNormal;  // 5E0
+		float                               calculatedDamage;    // 5F0
+		float                               scale;               // 5F4
+		REX::TEnumSet<Flags, std::uint32_t> flags;               // 5F8
+	};
+	static_assert(sizeof(Explosion) == 0x600);
+}

plugin/lib/commonlibf4/include/RE/E/ExteriorCellSingleton.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSTSingleton.h"
+#include "RE/N/NiPointer.h"
+
+namespace RE
+{
+	class bhkWorldM;
+
+	class ExteriorCellSingleton :
+		public BSTSingletonExplicit<ExteriorCellSingleton>
+	{
+	public:
+		[[nodiscard]] static ExteriorCellSingleton* GetSingleton()
+		{
+			static REL::Relocation<ExteriorCellSingleton**> singleton{ ID::ExteriorCellSingleton::Singleton };
+			return *singleton;
+		}
+
+		//members
+		NiPointer<bhkWorldM> exteriorWorld;
+	};
+	static_assert(sizeof(ExteriorCellSingleton) == 0x8);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraAliasInstanceArray.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class BGSRefAliasInstanceData;
+
+	class __declspec(novtable) ExtraAliasInstanceArray :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraAliasInstanceArray };
+		static constexpr auto VTABLE{ VTABLE::ExtraAliasInstanceArray };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kAliasInstanceArray };
+
+		// members
+		BSTArray<BGSRefAliasInstanceData> aliasArray;      // 18
+		BSReadWriteLock                   aliasArrayLock;  // 30
+	};
+	static_assert(sizeof(ExtraAliasInstanceArray) == 0x38);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraAmmo.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraAmmo :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraAmmo };
+		static constexpr auto VTABLE{ VTABLE::ExtraAmmo };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kAmmo };
+
+		// members
+		std::uint32_t count;  // 18
+	};
+	static_assert(sizeof(ExtraAmmo) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraBendableSplineParams.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraBendableSplineParams :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraBendableSplineParams };
+		static constexpr auto VTABLE{ VTABLE::ExtraBendableSplineParams };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kBendableSplineParams };
+
+		class ParamData_Untilv13
+		{
+			// members
+			float    slack;        // 00
+			float    thickness;    // 04
+			NiPoint3 halfExtents;  // 08
+		};
+		static_assert(sizeof(ParamData_Untilv13) == 0x14);
+
+		class ParamData : public ParamData_Untilv13
+		{
+			// members
+			bool endDetached;  // 14
+		};
+		static_assert(sizeof(ParamData) == 0x18);
+
+		// members
+		ParamData data;  // 18
+	};
+	static_assert(sizeof(ExtraBendableSplineParams) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraCellWaterType.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraCellWaterType :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraCellWaterType };
+		static constexpr auto VTABLE{ VTABLE::ExtraCellWaterType };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kWaterType };
+
+		// members
+		TESWaterForm* water;  // 18
+	};
+	static_assert(sizeof(ExtraCellWaterType) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraCharge.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraCharge :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraCharge };
+		static constexpr auto VTABLE{ VTABLE::ExtraCharge };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kCharge };
+
+		// members
+		float charge;  // 18
+	};
+	static_assert(sizeof(ExtraCharge) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraDataList.h

@@ -0,0 +1,207 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/B/BSIntrusiveRefCounted.h"
+#include "RE/B/BSSpinLock.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/B/BaseExtraList.h"
+#include "RE/E/EXTRA_DATA_TYPE.h"
+#include "RE/M/MemoryManager.h"
+#include "RE/T/TBO_InstanceData.h"
+
+namespace RE
+{
+	class BGSObjectInstanceExtra;
+	class BGSPrimitive;
+	class NiPoint3;
+
+	namespace detail
+	{
+		template <class T>
+		concept ExtraDataListConstraint =
+			std::derived_from<T, BSExtraData> &&
+			!std::is_pointer_v<T> &&
+			!std::is_reference_v<T>;
+	}
+
+	class ExtraDataList :
+		public BSIntrusiveRefCounted  // 00
+	{
+	public:
+		F4_HEAP_REDEFINE_NEW(ExtraDataList);
+
+		using ComparisonQualifier = bool (*)(const BSExtraData*);
+
+		enum class CLEAR_FOR
+		{
+			kContainer = 0x0,
+			kReference = 0x1
+		};
+
+		ExtraDataList()
+		{
+			using func_t = void (*)(ExtraDataList*);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::Ctor };
+			func(this);
+		}
+
+		inline void AddExtra(BSExtraData* a_extra)
+		{
+			const BSAutoWriteLock l{ extraRWLock };
+			extraData.AddExtra(a_extra);
+		}
+
+		inline void CopyList(const ExtraDataList* a_copy) noexcept
+		{
+			using func_t = decltype(&ExtraDataList::CopyList);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::CopyList };
+			func(this, a_copy);
+		}
+
+		inline TBO_InstanceData* CreateInstanceData(TESBoundObject* a_object, bool a_generateName)
+		{
+			using func_t = decltype(&ExtraDataList::CreateInstanceData);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::CreateInstanceData };
+			return func(this, a_object, a_generateName);
+		}
+
+		[[nodiscard]] BSExtraData* GetByType(EXTRA_DATA_TYPE a_type) const noexcept
+		{
+			const BSAutoReadLock l{ extraRWLock };
+			return extraData.GetByType(a_type);
+		}
+
+		template <detail::ExtraDataListConstraint T>
+		[[nodiscard]] T* GetByType() const noexcept
+		{
+			return static_cast<T*>(GetByType(T::TYPE));
+		}
+
+		[[nodiscard]] BGSMod::Attachment::Mod* GetLegendaryMod()
+		{
+			using func_t = decltype(&ExtraDataList::GetLegendaryMod);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::GetLegendaryMod };
+			return func(this);
+		}
+
+		[[nodiscard]] bool HasType(EXTRA_DATA_TYPE a_type) const noexcept
+		{
+			const BSAutoReadLock l{ extraRWLock };
+			return extraData.HasType(a_type);
+		}
+
+		template <detail::ExtraDataListConstraint T>
+		[[nodiscard]] bool HasType() const noexcept
+		{
+			return HasType(T::TYPE);
+		}
+
+		std::unique_ptr<BSExtraData> RemoveExtra(EXTRA_DATA_TYPE a_type)
+		{
+			const BSAutoWriteLock l{ extraRWLock };
+			return extraData.RemoveExtra(a_type);
+		}
+
+		template <detail::ExtraDataListConstraint T>
+		inline std::unique_ptr<T> RemoveExtra()
+		{
+			return std::unique_ptr<T>{ static_cast<T*>(RemoveExtra(T::TYPE).release()) };
+		}
+
+		inline bool SetBendableSplineInfo(float* a_thickness, float* a_slack, NiPoint3* a_halfExtents = nullptr, bool* a_detachedEnd = nullptr)
+		{
+			using func_t = decltype(&ExtraDataList::SetBendableSplineInfo);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetBendableSplineInfo };
+			return func(this, a_thickness, a_slack, a_halfExtents, a_detachedEnd);
+		}
+
+		inline void SetCount(std::int16_t a_count) noexcept
+		{
+			using func_t = decltype(&ExtraDataList::SetCount);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetCount };
+			func(this, a_count);
+		}
+
+		inline void SetDisplayNameFromInstanceData(BGSObjectInstanceExtra* a_instExtra, TESBoundObject* a_object, const BSTSmartPointer<TBO_InstanceData>& a_data)
+		{
+			using func_t = decltype(&ExtraDataList::SetDisplayNameFromInstanceData);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetDisplayNameFromInstanceData };
+			func(this, a_instExtra, a_object, a_data);
+		}
+
+		inline void SetOverrideName(const char* a_name)
+		{
+			using func_t = decltype(&ExtraDataList::SetOverrideName);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetOverrideName };
+			func(this, a_name);
+		}
+
+		inline void SetStartingWorldOrCell(TESForm* a_form)
+		{
+			using func_t = decltype(&ExtraDataList::SetStartingWorldOrCell);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetStartingWorldOrCell };
+			func(this, a_form);
+		}
+
+		inline float GetHealthPerc()
+		{
+			using func_t = decltype(&ExtraDataList::GetHealthPerc);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::GetHealthPerc };
+			return func(this);
+		}
+
+		inline void SetHealthPerc(float a_healthPerc)
+		{
+			using func_t = decltype(&ExtraDataList::SetHealthPerc);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetHealthPerc };
+			func(this, a_healthPerc);
+		}
+
+		inline bool ClearFavorite()
+		{
+			using func_t = decltype(&ExtraDataList::ClearFavorite);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::ClearFavorite };
+			return func(this);
+		}
+
+		inline bool IsFavorite()
+		{
+			using func_t = decltype(&ExtraDataList::IsFavorite);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::IsFavorite };
+			return func(this);
+		}
+
+		inline bool IsDamaged()
+		{
+			using func_t = decltype(&ExtraDataList::IsDamaged);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::IsDamaged };
+			return func(this);
+		}
+
+		inline bool CompareList(const ExtraDataList* a_compare, ComparisonQualifier a_qualifier)
+		{
+			using func_t = decltype(&ExtraDataList::CompareList);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::CompareList };
+			return func(this, a_compare, a_qualifier);
+		}
+
+		inline void SetFavorite(char a_quickKeyIndex)
+		{
+			using func_t = decltype(&ExtraDataList::SetFavorite);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::SetFavorite };
+			func(this, a_quickKeyIndex);
+		}
+
+		inline BGSPrimitive* GetPrimitive()
+		{
+			using func_t = decltype(&ExtraDataList::GetPrimitive);
+			static REL::Relocation<func_t> func{ ID::ExtraDataList::GetPrimitive };
+			return func(this);
+		}
+
+		// members
+		BaseExtraList           extraData;    // 08
+		mutable BSReadWriteLock extraRWLock;  // 20
+	};
+	static_assert(sizeof(ExtraDataList) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraEditorID.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraEditorID :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraEditorID };
+		static constexpr auto VTABLE{ VTABLE::ExtraEditorID };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kEditorID };
+
+		// members
+		BSFixedString editorID;  // 18
+	};
+	static_assert(sizeof(ExtraEditorID) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraFactionChanges.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/F/FACTION_RANK.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraFactionChanges :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraFactionChanges };
+		static constexpr auto VTABLE{ VTABLE::ExtraFactionChanges };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kFactionChanges };
+
+		// members
+		bool                                          removeCrimeFaction;  // 18
+		BSTArray<FACTION_RANK, BSTArrayHeapAllocator> factionChanges;      // 20
+		TESFaction*                                   crimeFaction;        // 38
+	};
+	static_assert(sizeof(ExtraFactionChanges) == 0x40);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraFavorite.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraFavorite :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraFavorite };
+		static constexpr auto VTABLE{ VTABLE::ExtraFavorite };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kFavorite };
+
+		// members
+		std::int8_t quickkeyIndex;  //18
+	};
+	static_assert(sizeof(ExtraFavorite) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraHealth.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraHealth :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraHealth };
+		static constexpr auto VTABLE{ VTABLE::ExtraHealth };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kHealth };
+
+		ExtraHealth(float a_health) :
+			BSExtraData(TYPE),
+			health(a_health)
+		{
+			REX::EMPLACE_VTABLE(this);
+		}
+
+		// members
+		float health;  // 18
+	};
+	static_assert(sizeof(ExtraHealth) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraInstanceData.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/B/BSTSmartPointer.h"
+#include "RE/T/TBO_InstanceData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraInstanceData :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraInstanceData };
+		static constexpr auto VTABLE{ VTABLE::ExtraInstanceData };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kInstanceData };
+
+		ExtraInstanceData();
+		ExtraInstanceData(const TESBoundObject* a_base, BSTSmartPointer<TBO_InstanceData> a_data);
+
+		// members
+		const TESBoundObject*             base{ nullptr };  // 18
+		BSTSmartPointer<TBO_InstanceData> data;             // 20
+	};
+	static_assert(sizeof(ExtraInstanceData) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraLeveledCreature.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraLeveledCreature :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraLeveledCreature };
+		static constexpr auto VTABLE{ VTABLE::ExtraLeveledCreature };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kLeveledCreature };
+
+		// members
+		TESActorBase* originalBase;   // 18
+		TESActorBase* templates[13];  // 20
+	};
+	static_assert(sizeof(ExtraLeveledCreature) == 0x88);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraLight.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/R/REFR_LIGHT.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraLight :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraLight };
+		static constexpr auto VTABLE{ VTABLE::ExtraLight };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kLight };
+
+		// members
+		REFR_LIGHT lightdata;  // 18
+	};
+	static_assert(sizeof(ExtraLight) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraLocation.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraLocation :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraLocation };
+		static constexpr auto VTABLE{ VTABLE::ExtraLocation };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kLocation };
+
+		// members
+		BGSLocation* location;  // 18
+	};
+	static_assert(sizeof(ExtraLocation) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraLock.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class REFR_LOCK;
+
+	class __declspec(novtable) ExtraLock :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraLock };
+		static constexpr auto VTABLE{ VTABLE::ExtraLock };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kLock };
+
+		// members
+		REFR_LOCK* lock;  // 18
+	};
+	static_assert(sizeof(ExtraLock) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraMapMarker.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class MapMarkerData;
+
+	class __declspec(novtable) ExtraMapMarker :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraMapMarker };
+		static constexpr auto VTABLE{ VTABLE::ExtraMapMarker };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kMapMarker };
+
+		// members
+		MapMarkerData* mapMarkerData;  // 18
+	};
+	static_assert(sizeof(ExtraMapMarker) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraMaterialSwap.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraMaterialSwap :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraMaterialSwap };
+		static constexpr auto VTABLE{ VTABLE::ExtraMaterialSwap };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kMaterialSwap };
+
+		ExtraMaterialSwap() :
+			BSExtraData(TYPE)
+		{
+			REX::EMPLACE_VTABLE(this);
+		}
+
+		// members
+		BGSMaterialSwap* swap{ nullptr };  // 18
+	};
+	static_assert(sizeof(ExtraMaterialSwap) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraPoison.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class AlchemyItem;
+
+	class __declspec(novtable) ExtraPoison :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraPoison };
+		static constexpr auto VTABLE{ VTABLE::ExtraPoison };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kPoison };
+
+		// members
+		std::uint32_t count;   // 18
+		AlchemyItem*  poison;  // 20
+	};
+	static_assert(sizeof(ExtraPoison) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraPowerLinks.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/B/BSTArray.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraPowerLinks :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraPowerLinks };
+		static constexpr auto VTABLE{ VTABLE::ExtraPowerLinks };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kPowerLinks };
+
+		class Element
+		{
+		public:
+			// members
+			TESFormID     formID;    // 0
+			std::uint32_t linkType;  // 4
+		};
+		static_assert(sizeof(Element) == 0x8);
+
+		// members
+		BSTArray<Element> powerLinks;  // 18
+	};
+	static_assert(sizeof(ExtraPowerLinks) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraRadioData.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/R/RADIO_DATA.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraRadioData :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraRadioData };
+		static constexpr auto VTABLE{ VTABLE::ExtraRadioData };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kRadioData };
+
+		// members
+		RADIO_DATA data;  // 18
+	};
+	static_assert(sizeof(ExtraRadioData) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraRadioReceiver.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/T/TESObjectACTIDefs.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraRadioReceiver :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraRadioReceiver };
+		static constexpr auto VTABLE{ VTABLE::ExtraRadioReceiver };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kRadioReceiver };
+
+		// members
+		TESObjectACTIDefs::RadioReceiverData data;  // 18
+	};
+	static_assert(sizeof(ExtraRadioReceiver) == 0x30);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraRadioRepeater.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraRadioRepeater :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraRadioRepeater };
+		static constexpr auto VTABLE{ VTABLE::ExtraRadioRepeater };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kRadioRepeater };
+
+		// members
+		BSPointerHandle<TESObjectREFR, BSUntypedPointerHandle<21, 5>> transmitterToRepeat;  // 18
+		float                                                         innerRadius;          // 1C
+		float                                                         outerRadius;          // 20
+		bool                                                          unlimitedRange;       // 24
+	};
+	static_assert(sizeof(ExtraRadioRepeater) == 0x28);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraRagDollData.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/R/RagDollData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraRagDolldata :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraRagDollData };
+		static constexpr auto VTABLE{ VTABLE::ExtraRagDollData };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kRagdollData };
+
+		// members
+		RagDollData* ragDollData;  // 18
+	};
+	static_assert(sizeof(ExtraRagDolldata) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraReferenceHandles.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/B/BSPointerHandle.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraReferenceHandles :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraReferenceHandles };
+		static constexpr auto VTABLE{ VTABLE::ExtraReferenceHandles };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kReferenceHandle };
+
+		// members
+		ObjectRefHandle originalRef;   // 18
+		ObjectRefHandle containerRef;  // 1C
+	};
+	static_assert(sizeof(ExtraReferenceHandles) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraStartingWorldOrCell.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraStartingWorldOrCell :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraStartingWorldOrCell };
+		static constexpr auto VTABLE{ VTABLE::ExtraStartingWorldOrCell };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kStartingWorldOrCell };
+
+		ExtraStartingWorldOrCell() :
+			ExtraStartingWorldOrCell(nullptr)
+		{}
+
+		ExtraStartingWorldOrCell(TESForm* a_form) :
+			BSExtraData(TYPE),
+			startingWorldOrCell(a_form)
+		{
+			REX::EMPLACE_VTABLE(this);
+		}
+
+		// members
+		TESForm* startingWorldOrCell;  // 18
+	};
+	static_assert(sizeof(ExtraStartingWorldOrCell) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraTeleport.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class DoorTeleportData;
+
+	class __declspec(novtable) ExtraTeleport :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraTeleport };
+		static constexpr auto VTABLE{ VTABLE::ExtraTeleport };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kTeleport };
+
+		// members
+		DoorTeleportData* teleportData;  // 18
+	};
+	static_assert(sizeof(ExtraTeleport) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraTextDisplayData.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/B/BSFixedString.h"
+#include "RE/B/BSTArray.h"
+#include "RE/B/BSTTuple.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraTextDisplayData :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraTextDisplayData };
+		static constexpr auto VTABLE{ VTABLE::ExtraTextDisplayData };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kTextDisplayData };
+
+		enum class DisplayDataType
+		{
+			kUninitialized = -1,
+			kCustomName = -2
+		};
+
+		[[nodiscard]] const BSFixedStringCS& GetDisplayName(TESBoundObject* a_baseObject)
+		{
+			using func_t = decltype(&ExtraTextDisplayData::GetDisplayName);
+			static REL::Relocation<func_t> func{ ID::ExtraTextDisplayData::GetDisplayName };
+			return func(this, a_baseObject);
+		}
+
+		// members
+		BSFixedStringCS                              displayName;       // 18
+		BGSMessage*                                  displayNameText;   // 20
+		TESQuest*                                    ownerQuest;        // 28
+		REX::TEnumSet<DisplayDataType, std::int32_t> ownerInstance;     // 30
+		BSTArray<BSTTuple<BSFixedString, TESForm*>>* textPairs;         // 38
+		std::uint16_t                                customNameLength;  // 40
+	};
+	static_assert(sizeof(ExtraTextDisplayData) == 0x48);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraTresPassPackage.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+#include "RE/T/TrespassPackage.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraTresPassPackage :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraTresPassPackage };
+		static constexpr auto VTABLE{ VTABLE::ExtraTresPassPackage };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kTresPassPackage };
+
+		// members
+		TrespassPackage* pack;  // 18
+	};
+	static_assert(sizeof(ExtraTresPassPackage) == 0x20);
+}

plugin/lib/commonlibf4/include/RE/E/ExtraUniqueID.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/B/BSExtraData.h"
+
+namespace RE
+{
+	class __declspec(novtable) ExtraUniqueID :
+		public BSExtraData  // 00
+	{
+	public:
+		static constexpr auto RTTI{ RTTI::ExtraUniqueID };
+		static constexpr auto VTABLE{ VTABLE::ExtraUniqueID };
+		static constexpr auto TYPE{ EXTRA_DATA_TYPE::kUniqueID };
+
+		// members
+		std::uint16_t uniqueID;  // 18
+		std::uint32_t baseID;    // 1C
+	};
+	static_assert(sizeof(ExtraUniqueID) == 0x20);
+}