feat: BGSBaseForm classes

CommonLibSF/include/RE/B/BGSAimAssistModel.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "RE/B/BGSBaseForm.h"
+#include "RE/I/IBGSBaseFormData.h"
+
+namespace RE
+{
+	class AimAssistData : public IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(AimAssistData);
+
+		~AimAssistData() override;  // 00
+
+		void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) override;  // 03
+		bool                 Compare(IBGSBaseFormData* a_data) override;                                // 04
+		void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) override;                 // 05
+		const BSFixedString& GetFormDataType() override;                                                // 06 - { return "AimAssistData"; }
+
+		// members
+		float innerConeAngle;                   // 08
+		float outerConeAngle;                   // 0C
+		float steeringDegreesPerSec;            // 10
+		float pitchScale;                       // 14
+		float innerSteeringRing;                // 18
+		float outerSteeringRing;                // 1C
+		float friction;                         // 20
+		float moveFollowDegreesPerSec;          // 24
+		float snapSteeringMultADS;              // 28
+		float snapSecondsADS;                   // 2C
+		float snapConeAngleADS;                 // 30
+		float noSteering;                       // 34
+		float bulletBendingConeAngle;           // 38
+		float snapSteeringMultInnerRingADS;     // 3C
+		float snapSteeringMultOuterRingADS;     // 40
+		float innerConeAngleMultADS;            // 44
+		float outerConeAngleMultADS;            // 48
+		float innerSteeringRingMultADS;         // 4C
+		float outerSteeringRingMultADS;         // 50
+		float frictionMultADS;                  // 54
+		float steeringDegreesPerSecondMultADS;  // 58
+		bool  aimAssistEnabled;                 // 5C
+	};
+	static_assert(sizeof(AimAssistData) == 0x60);
+
+	class BGSAimAssistModel : public BGSBaseFormT<AimAssistData, FormType::kAAMD>
+	{
+	public:
+		SF_RTTI_VTABLE(BGSAimAssistModel);
+		SF_FORMTYPE(AAMD);
+
+		~BGSAimAssistModel() override;  // 00
+	};
+	static_assert(sizeof(BGSAimAssistModel) == 0x98);
+}

CommonLibSF/include/RE/B/BGSAimAssistPoseData.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "RE/B/BSTArray.h"
+#include "RE/T/TESForm.h"
+
+namespace RE
+{
+	class BGSAimAssistPoseData : public TESForm
+	{
+	public:
+		SF_RTTI_VTABLE(BGSAimAssistPoseData);
+		SF_FORMTYPE(AAPD);
+
+		struct AttachPoint
+		{
+			BSFixedString start;  // 00
+			BSFixedString end;    // 08
+			float         unk10;  // 10
+			float         unk14;  // 14
+		};
+		static_assert(sizeof(AttachPoint) == 0x18);
+
+		~BGSAimAssistPoseData() override;  // 00
+
+		// members
+		AttachPoint           attachPoint;  // 30
+		BSTArray<AttachPoint> connections;  // 48
+	};
+	static_assert(sizeof(BGSAimAssistPoseData) == 0x58);
+}

CommonLibSF/include/RE/B/BGSAimDownSightModel.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "RE/B/BGSBaseForm.h"
+#include "RE/I/IBGSBaseFormData.h"
+#include "RE/N/NiPoint3.h"
+
+namespace RE
+{
+	class TESImageSpaceModifier;
+
+	class AimDownSightData : public IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(AimDownSightData);
+
+		enum class OVERLAY
+		{
+			kDefault,
+			kFine,
+			kDuplex,
+			kGerman,
+			kDot,
+			kMilDot,
+			kCircle,
+			kOldRangefind,
+			kModernRangefind,
+			kSVD,
+			kHandPainted,
+			kBinoculars,
+			kCross,
+			kDoubleZero,
+			kRangefinder1,
+			kRangefinder2,
+			kRectangle,
+			kTactical4x,
+			kTactical2x
+		};
+
+		~AimDownSightData() override;  // 00
+
+		// override (IBGSBaseFormData)
+		void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) override;  // 03
+		bool                 Compare(IBGSBaseFormData* a_data) override;                                // 04
+		void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) override;                 // 05
+		const BSFixedString& GetFormDataType() override;                                                // 06 - { return "AimDownSightData"; }
+
+		// members
+		TESImageSpaceModifier*                  imod;                         // 08
+		NiPoint3                                cameraOffset;                 // 10
+		float                                   distanceFromCameraOffsetADS;  // 1C
+		float                                   fovMult;                      // 20
+		bool                                    heightDelayEnabledADS;        // 24
+		float                                   heightDelayADS;               // 28
+		bool                                    depthEnabledADS;              // 2C
+		float                                   depthDelayADS;                // 30
+		stl::enumeration<OVERLAY, std::uint8_t> overlay;                      // 34
+	};
+	static_assert(sizeof(AimDownSightData) == 0x38);
+
+	class BGSAimDownSightModel : public BGSBaseFormT<AimDownSightData, FormType::kZOOM>
+	{
+	public:
+		SF_RTTI_VTABLE(BGSAimDownSightModel);
+		SF_FORMTYPE(ZOOM);
+
+		~BGSAimDownSightModel() override;  // 00
+	};
+	static_assert(sizeof(BGSAimDownSightModel) == 0x70);
+}

CommonLibSF/include/RE/B/BGSAimModel.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "RE/B/BGSBaseForm.h"
+#include "RE/I/IBGSBaseFormData.h"
+#include "RE/N/NiPoint2.h"
+
+namespace RE
+{
+	class AimModelData : public IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(AimModelData);
+
+		~AimModelData() override;  // 00
+
+		// override (IBGSBaseFormData)
+		void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) override;  // 03
+		bool                 Compare(IBGSBaseFormData* a_data) override;                                // 04
+		void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) override;                 // 05
+		const BSFixedString& GetFormDataType() override;                                                // 06 - { return "AimModelData"; }
+
+		// members
+		NiPoint2      coneOfFireAngle;            // 08
+		float         coneOfFireIncreasePerShot;  // 10
+		float         coneOfFireDecreasePerShot;  // 14
+		float         coneOfFireDecreaseDelay;    // 18
+		float         coneOfFireSneakMult;        // 1C
+		float         recoilDiminishSpringForce;  // 20
+		float         recoilDiminishSpringMult;   // 24
+		NiPoint2      recoilPerShot;              // 28
+		float         recoilHipMult;              // 30
+		std::uint32_t runawayRecoilShots;         // 34
+		float         recoilArc;                  // 38
+		float         recoilArcRotate;            // 3C
+		float         coneOfFireIronSightsMult;   // 40
+		float         baseStability;              // 44
+	};
+	static_assert(sizeof(AimModelData) == 0x48);
+
+	class BGSAimModel : public BGSBaseFormT<AimModelData, FormType::kAMDL>
+	{
+	public:
+		SF_RTTI_VTABLE(BGSAimModel);
+		SF_FORMTYPE(AMDL);
+
+		~BGSAimModel() override;  // 00
+	};
+	static_assert(sizeof(BGSAimModel) == 0x80);
+}

CommonLibSF/include/RE/B/BGSAimOpticalSightModel.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "RE/B/BGSBaseForm.h"
+#include "RE/I/IBGSBaseFormData.h"
+
+namespace RE
+{
+	class BGSArtObject;
+	class TESObjectLIGH;
+
+	class AimOpticalSightData : public IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(AimOpticalSightData);
+
+		~AimOpticalSightData() override;  // 00
+
+		// override (IBGSBaseFormData)
+		void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) override;  // 03
+		bool                 Compare(IBGSBaseFormData* a_data) override;                                // 04
+		void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) override;                 // 05
+		const BSFixedString& GetFormDataType() override;                                                // 06 - return { "AimOpticalSightData"; }
+
+		// members
+		float          unk08;                        // 08
+		float          unk0C;                        // 0C
+		TESObjectLIGH* light;                        // 10
+		BGSArtObject*  beamArt;                      // 18
+		BGSArtObject*  dotArt;                       // 20
+		BSFixedString  nodeName;                     // 28
+		float          beamReactivationDelayReload;  // 30
+		float          beamDeactivationDelayReload;  // 34
+		float          beamReactivationDelayFiring;  // 38
+		float          unk3C;                        // 3C
+		bool           unk40;                        // 40
+		bool           hideBeamByDefault;            // 41
+		bool           showBeamAtHip;                // 42
+		bool           unk43;                        // 43
+	};
+	static_assert(sizeof(AimOpticalSightData) == 0x48);
+
+	class BGSAimOpticalSightModel : public BGSBaseFormT<AimOpticalSightData, FormType::kAOPS>
+	{
+	public:
+		SF_RTTI_VTABLE(BGSAimOpticalSightModel);
+		SF_FORMTYPE(AOPS);
+
+		~BGSAimOpticalSightModel() override;  // 00
+	};
+	static_assert(sizeof(BGSAimOpticalSightModel) == 0x80);
+}

CommonLibSF/include/RE/B/BGSBaseForm.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "RE/T/TESForm.h"
+
+namespace RE
+{
+	class BGSBaseForm :
+		public TESForm  // 00
+	{
+	public:
+		SF_RTTI(BGSBaseForm);
+
+		~BGSBaseForm() override;  // 00
+	};
+	static_assert(sizeof(BGSBaseForm) == 0x30);
+
+	template <class T, FormType>
+	class BGSBaseFormT :
+		public BGSBaseForm  // 00
+	{
+	public:	
+		// members
+		T* ptr;   // 30
+		T  data;  // 38
+	};
+}

CommonLibSF/include/RE/B/BGSMeleeAimAssistModel.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "RE/B/BGSBaseForm.h"
+#include "RE/I/IBGSBaseFormData.h"
+
+namespace RE
+{
+	class MeleeAimAssistData : public IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(MeleeAimAssistData);
+
+		~MeleeAimAssistData() override;  // 00
+
+		// override (IBGSBaseFormData)
+		void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) override;  // 03
+		bool                 Compare(IBGSBaseFormData* a_data) override;                                // 04
+		void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) override;                 // 05
+		const BSFixedString& GetFormDataType() override;                                                // 06 - return { "MeleeAimAssistData"; }
+
+		// members
+		float outerConeAngle;             // 08
+		float innerConeAngle;             // 0C
+		float steeringDegreesPerSec;      // 10
+		float snapSteeringMultOuterRing;  // 14
+		float snapSteeringMultInnerRing;  // 18
+		float maxAimAssistDistance;       // 1C
+		float unk20;                      // 20
+		bool  aimAssistEnabled;           // 24
+	};
+	static_assert(sizeof(MeleeAimAssistData) == 0x28);
+
+	class BGSMeleeAimAssistModel : public BGSBaseFormT<MeleeAimAssistData, FormType::kMAAM>
+	{
+	public:
+		SF_RTTI_VTABLE(BGSMeleeAimAssistModel);
+		SF_FORMTYPE(MAAM);
+
+		~BGSMeleeAimAssistModel() override;  // 00
+	};
+	static_assert(sizeof(BGSMeleeAimAssistModel) == 0x60);
+}

CommonLibSF/include/RE/B/BGSWeaponBarrelModel.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "RE/B/BGSBaseForm.h"
+#include "RE/I/IBGSBaseFormData.h"
+
+namespace RE
+{
+	class BGSWeaponBarrelData : public IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(BGSWeaponBarrelData);
+
+		~BGSWeaponBarrelData() override;  // 00
+
+		// override (IBGSBaseFormData)
+		void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) override;  // 03
+		bool                 Compare(IBGSBaseFormData* a_data) override;                                // 04
+		void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) override;                 // 05
+		const BSFixedString& GetFormDataType() override;                                                // 06 - return { "WeaponBarrelData"; }
+
+		// members
+		bool  allowCoverState;                  // 08
+		float coverDetectionDistance;           // 0C
+		float enterCoverAnimationTime;          // 10
+		float hipFireDuringCoverAnimationTime;  // 14
+	};
+	static_assert(sizeof(BGSWeaponBarrelData) == 0x18);
+
+	class BGSWeaponBarrelModel : public BGSBaseFormT<BGSWeaponBarrelData, FormType::kWBAR>
+	{
+	public:
+		SF_RTTI_VTABLE(BGSWeaponBarrelModel);
+		SF_FORMTYPE(WBAR);
+
+		~BGSWeaponBarrelModel() override;  // 00
+	};
+	static_assert(sizeof(BGSWeaponBarrelModel) == 0x50);
+}

CommonLibSF/include/RE/I/IBGSBaseFormData.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "RE/B/BSFixedString.h"
+
+namespace RE
+{
+	class TESForm;
+
+	class IBGSBaseFormData
+	{
+	public:
+		SF_RTTI_VTABLE(IBGSBaseFormData);
+
+		virtual ~IBGSBaseFormData();  // 00
+
+		// add
+		virtual void                 InitializeFormData();                                                 // 01
+		virtual void                 InitData();                                                           // 02
+		virtual void                 Load(std::uint64_t a_arg2, std::uint32_t a_id, TESFile* a_file) = 0;  // 03
+		virtual bool                 Compare(IBGSBaseFormData* a_data) = 0;                                // 04
+		virtual void                 Copy(IBGSBaseFormData* a_data, TESForm* a_owner) = 0;                 // 05
+		virtual const BSFixedString& GetFormDataType() = 0;                                                // 06
+	};
+	static_assert(sizeof(IBGSBaseFormData) == 0x8);
+}