diff --git a/CommonLibSF/include/RE/A/AVMData.h b/CommonLibSF/include/RE/A/AVMData.h new file mode 100644 index 00000000..961b4e55 --- /dev/null +++ b/CommonLibSF/include/RE/A/AVMData.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/B/BSFixedString.h" +#include "RE/C/Color.h" + +namespace RE +{ + struct AVMData + { + public: + enum class TYPE + { + kNone, + kSimpleGroup, + kComplexGroup, + kModulation + }; + + struct Entry + { + BSFixedString name; // 00 + BSFixedString texturePath; // 08 + Color color; // 10 + std::uint32_t intensity; // 14 + }; + + // members + stl::enumeration type; // 00 + BSFixedString category; // 08 + Entry unk10; // 10 + }; + static_assert(sizeof(AVMData) == 0x28); +} diff --git a/CommonLibSF/include/RE/A/AlchemyItem.h b/CommonLibSF/include/RE/A/AlchemyItem.h new file mode 100644 index 00000000..4a9bf194 --- /dev/null +++ b/CommonLibSF/include/RE/A/AlchemyItem.h @@ -0,0 +1,60 @@ +#pragma once + +#include "RE/B/BGSCraftingResourceOwner.h" +#include "RE/B/BGSCraftingUseSound.h" +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSEquipType.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSPickupPutdownSounds.h" +#include "RE/M/MagicItem.h" +#include "RE/T/TESDescription.h" +#include "RE/T/TESWeightForm.h" + +namespace RE +{ + class SpellItem; + + class AlchemyItem : + public MagicItem, // 000 + public BGSModelMaterialSwap, // 188 + public TESWeightForm, // 1B0 + public BGSEquipType, // 1C0 + public BGSDestructibleObjectForm, // 1D0 + public BGSPickupPutdownSounds, // 1E0 + public BGSCraftingUseSound, // 240 + public TESDescription, // 280 + public BGSCraftingResourceOwner // 298 + { + public: + SF_RTTI_VTABLE(AlchemyItem); + SF_FORMTYPE(ALCH); + + enum class AlchemyFlag + { + kNone = 0, + kCostOverride = 1 << 0, + kFoodItem = 1 << 1, + kExtendDuration = 1 << 3, + kMedicine = 1 << 16, + kPoison = 1 << 17 + }; + + class Data : + public MagicItem::Data // 00 + { + public: + // members + SpellItem* addictionItem; // 08 + float addictionChance; // 10 + BGSAudio::WwiseSoundHook consumptionSound; // 18 + BGSLocalizedString addictionName; // 48 + }; + static_assert(sizeof(Data) == 0x50); + + ~AlchemyItem() override; // 00 + + // members + Data data; // 2B8 + }; + static_assert(sizeof(AlchemyItem) == 0x308); +} diff --git a/CommonLibSF/include/RE/B/BGSAcousticSpace.h b/CommonLibSF/include/RE/B/BGSAcousticSpace.h new file mode 100644 index 00000000..6471b827 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAcousticSpace.h @@ -0,0 +1,36 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESBoundObject.h" +#include "RE/W/WWiseSoundHook.h" + +namespace RE +{ + class BGSAmbienceSet; + class BGSMusicType; + class BGSReverbParameters; + + class BGSAcousticSpace : public TESBoundObject + { + public: + SF_RTTI_VTABLE(BGSAcousticSpace); + SF_FORMTYPE(ASPC); + + ~BGSAcousticSpace() override; // 00 + + // members + BGSAudio::WwiseSoundHook sound0; // 118 + BGSAudio::WwiseSoundHook sound1; // 148 + BGSAudio::WwiseSoundHook sound2; // 178 + BGSMusicType* music; // 1A8 + BGSAmbienceSet* ambienceSet; // 1B0 + BGSReverbParameters* environmentType; // 1B8 + std::uint32_t unk1C0; // 1C0 + float unk1C4; // 1C4 + float unk1C8; // 1C8 + std::uint8_t unk1CC; // 1CC + std::uint8_t unk1CD; // 1CD + std::uint32_t unk1D0; // 1D0 + }; + static_assert(sizeof(BGSAcousticSpace) == 0x1D8); +} diff --git a/CommonLibSF/include/RE/B/BGSArtObject.h b/CommonLibSF/include/RE/B/BGSArtObject.h new file mode 100644 index 00000000..c4338a02 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSArtObject.h @@ -0,0 +1,43 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class EffectShader; + + class BGSArtObject : + public TESBoundObject, // 000 + public BGSKeywordForm, // 118 + public BGSModelMaterialSwap // 148 + { + public: + SF_RTTI_VTABLE(BGSArtObject); + SF_FORMTYPE(ARTO); + + enum class ArtType + { + kMagicCastingArt = 0, + kMagicHitEffect = 1, + kMagicEnchantEffect = 2 + }; + + struct Data // DNAM + { + public: + // members + stl::enumeration artType; // 0 + std::uint32_t unk04; // 4 + }; + static_assert(sizeof(Data) == 0x8); + + ~BGSArtObject() override; // 00 + + // members + Data data; // 170 + EffectShader* effectShader; // 178 + }; + static_assert(sizeof(BGSArtObject) == 0x180); +} diff --git a/CommonLibSF/include/RE/B/BGSAudioOcclusionPrimitive.h b/CommonLibSF/include/RE/B/BGSAudioOcclusionPrimitive.h new file mode 100644 index 00000000..cceff1b2 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAudioOcclusionPrimitive.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class BGSAudioOcclusionPrimitive : public TESBoundObject + { + public: + SF_RTTI_VTABLE(BGSAudioOcclusionPrimitive); + SF_FORMTYPE(AOPF); + + ~BGSAudioOcclusionPrimitive() override; // 00 + + // members + float unk118; // 118 + float unk11C; // 11C + }; + static_assert(sizeof(BGSAudioOcclusionPrimitive) == 0x120); +} diff --git a/CommonLibSF/include/RE/B/BGSBendableSpline.h b/CommonLibSF/include/RE/B/BGSBendableSpline.h new file mode 100644 index 00000000..b0afd1dc --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSBendableSpline.h @@ -0,0 +1,34 @@ +#pragma once + +#include "RE/N/NiColor.h" +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class BGSMaterialPathForm; + + class BGSBendableSpline : public TESBoundObject + { + public: + SF_RTTI_VTABLE(BGSBendableSpline); + SF_FORMTYPE(BNDS); + + struct SplineData + { + public: + // members + float numTiles; // 00 + std::uint16_t numSlices; // 04 + std::uint16_t numRelativeTiles; // 06 + NiColor color; // 08 + float windSensibility; // 14 + float flexibility; // 18 + }; + static_assert(sizeof(SplineData) == 0x1C); + + // members + SplineData data; // 118 + BGSMaterialPathForm* materialPath; // 138 + }; + static_assert(sizeof(BGSBendableSpline) == 0x140); +} diff --git a/CommonLibSF/include/RE/B/BGSBiomeMarkerObject.h b/CommonLibSF/include/RE/B/BGSBiomeMarkerObject.h new file mode 100644 index 00000000..362936b3 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSBiomeMarkerObject.h @@ -0,0 +1,29 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESModel.h" + +namespace RE +{ + class TESLevItem; + + class BGSBiomeMarkerObject : + public TESBoundObject, // 000 + public TESModel, // 118 + public BGSKeywordForm // 138 + { + public: + SF_RTTI_VTABLE(BGSBiomeMarkerObject); + SF_FORMTYPE(BMMO); + + ~BGSBiomeMarkerObject() override; // 00 + + // members + TESCondition conditions; // 168 + BGSKeyword* type; // 178 + TESLevItem* floraList; // 180 + }; + static_assert(sizeof(BGSBiomeMarkerObject) == 0x188); +} diff --git a/CommonLibSF/include/RE/B/BGSExplosion.h b/CommonLibSF/include/RE/B/BGSExplosion.h new file mode 100644 index 00000000..b60007c7 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSExplosion.h @@ -0,0 +1,68 @@ +#pragma once + +#include "RE/B/BGSPreloadable.h" +#include "RE/B/BGSTypedFormValuePair.h" +#include "RE/B/BSTArray.h" +#include "RE/B/BSTTuple3.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESEnchantableForm.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESImageSpaceModifiableForm.h" +#include "RE/T/TESModel.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSConditionForm; + class BGSImpactDataSet; + class BGSProjectile; + class TESObjectLIGH; + + struct BGSExplosionData // DATA + { + float unk00; // 00 + std::uint32_t unk04; // 04 + std::uint32_t unk08; // 08 + std::uint32_t unk0C; // 0C + BGSImpactDataSet* impactDataSet; // 10 + BGSProjectile* spawnProjectile; // 18 + TESBoundObject* impactPlacedObject; // 20 + TESObjectLIGH* light; // 28 + BGSConditionForm* conditions; // 30 + BGSAudio::WwiseSoundHook sound; // 38 + BSTArray>* damageTypes; // 68 + std::uint32_t unk70; // 70 + std::uint32_t unk74; // 74 + std::uint32_t unk78; // 78 + std::uint32_t unk7C; // 7C + std::uint32_t unk80; // 80 + std::uint32_t unk84; // 84 + std::uint32_t unk88; // 88 + float unk8C; // 8C + std::uint32_t unk90; // 90 + std::uint32_t unk94; // 94 + std::uint32_t unk98; // 98 + std::uint32_t unk9C; // 9C + std::uint32_t unkA0; // A0 + }; + static_assert(sizeof(BGSExplosionData) == 0xA8); + + class BGSExplosion : + public TESBoundObject, // 000 + public TESFullName, // 118 + public TESModel, // 128 + public TESEnchantableForm, // 148 + public BGSPreloadable, // 160 + public TESImageSpaceModifiableForm // 168 + { + public: + SF_RTTI_VTABLE(BGSExplosion); + SF_FORMTYPE(EXPL); + + ~BGSExplosion() override; // 00 + + // members + BGSExplosionData data; // 178 + }; + static_assert(sizeof(BGSExplosion) == 0x220); +} diff --git a/CommonLibSF/include/RE/B/BGSGenericBaseForm.h b/CommonLibSF/include/RE/B/BGSGenericBaseForm.h new file mode 100644 index 00000000..4ffc7119 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSGenericBaseForm.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSNavmeshableObject.h" +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class BGSGenericBaseFormTemplate; + + class BGSGenericBaseForm : + public TESBoundObject, // 000 + public BGSNavmeshableObject // 118 + { + public: + SF_RTTI_VTABLE(BGSGenericBaseForm); + SF_FORMTYPE(GBFM); + + // members + BGSEditorID formEditorID; // 120 + BGSGenericBaseFormTemplate* genericBaseFormTemplate; // 130 + }; + static_assert(sizeof(BGSGenericBaseForm) == 0x138); +} diff --git a/CommonLibSF/include/RE/B/BGSHazard.h b/CommonLibSF/include/RE/B/BGSHazard.h new file mode 100644 index 00000000..8f3b8463 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSHazard.h @@ -0,0 +1,68 @@ +#pragma once + +#include "RE/B/BGSPreloadable.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESImageSpaceModifiableForm.h" +#include "RE/T/TESModel.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSImpactDataSet; + class MagicItem; + class TESObjectLIGH; + + struct BGSHazardData // DATA + { + public: + enum class BGSHazardFlags + { + kNone = 0, + kPCOnly = 1 << 0, + kInheritDuration = 1 << 1, + kAlignToNormal = 1 << 2, + kInheritRadius = 1 << 3, + kDropToGround = 1 << 4, + kTaperEffectivenessbyProximity = 1 << 5, + kIncreasedGravity = 1 << 6, + kReversedGravity = 1 << 7 + }; + + BGSAudio::WwiseSoundHook sound; // 00 + MagicItem* spell; // 30 + TESObjectLIGH* light; // 38 + BGSImpactDataSet* impactDataSet; // 40 + std::uint32_t radius; // 48 + std::uint32_t lifetime; // 4C + std::uint32_t imageSpaceRadius; // 50 + float targetInterval; // 54 + std::uint32_t unk58; // 58 + std::uint32_t unk5C; // 5C + std::uint32_t unk60; // 60 + float unk64; // 64 + float unk68; // 68 + std::uint32_t unk6C; // 6C + }; + static_assert(sizeof(BGSHazardData) == 0x70); + + class BGSHazard : + public TESBoundObject, // 000 + public TESFullName, // 118 + public TESModel, // 128 + public BGSPreloadable, // 148 + public TESImageSpaceModifiableForm // 150 + { + public: + SF_RTTI_VTABLE(BGSHazard); + SF_FORMTYPE(HAZD); + + ~BGSHazard() override; // 00 + + // members + BGSHazardData data; // 160 + TESCondition conditions; // 1D0 + }; + static_assert(sizeof(BGSHazard) == 0x1E0); +} diff --git a/CommonLibSF/include/RE/B/BGSIdleCollection.h b/CommonLibSF/include/RE/B/BGSIdleCollection.h new file mode 100644 index 00000000..6b1ad412 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSIdleCollection.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/B/BaseFormComponent.h" + +namespace RE +{ + class TESIdleForm; + + class BGSIdleCollection : public BaseFormComponent + { + public: + SF_RTTI_VTABLE(BGSIdleCollection); + + ~BGSIdleCollection() override; // 00 + + // override (BaseFormComponent) + const BSFixedString& GetFormComponentType() const override; // 01 - { return "BGSIdleCollection_Component"; } + void InitializeDataComponent() override; // 02 - { return; } + + // members + BSTArray idles; // 08 + float timerCheckForIdle; // 18 + std::uint8_t idleFlags; // 1C + }; + static_assert(sizeof(BGSIdleCollection) == 0x20); +} diff --git a/CommonLibSF/include/RE/B/BGSIdleMarker.h b/CommonLibSF/include/RE/B/BGSIdleMarker.h new file mode 100644 index 00000000..66fa31e6 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSIdleMarker.h @@ -0,0 +1,30 @@ +#pragma once + +#include "RE/B/BGSIdleCollection.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESModel.h" + +namespace RE +{ + class BGSAction; + + class BGSIdleMarker : + public TESBoundObject, // 000 + public BGSKeywordForm, // 118 + public TESModel, // 148 + public BGSIdleCollection // 168 + { + public: + SF_RTTI_VTABLE(BGSIdleMarker); + SF_FORMTYPE(IDLM); + + ~BGSIdleMarker() override; // 00 + + // members + BGSKeyword* animArchType; // 188 + BGSKeyword* flavorAnim; // 190 + BGSAction* action; // 198 + }; + static_assert(sizeof(BGSIdleMarker) == 0x1A0); +} diff --git a/CommonLibSF/include/RE/B/BGSLegendaryItem.h b/CommonLibSF/include/RE/B/BGSLegendaryItem.h new file mode 100644 index 00000000..82da3bb1 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSLegendaryItem.h @@ -0,0 +1,29 @@ +#pragma once + +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class TESLevItem; + + class BGSLegendaryItem : + public TESBoundObject, // 000 + public BGSModelMaterialSwap, // 118 + public TESFullName // 140 + { + public: + SF_RTTI_VTABLE(BGSLegendaryItem); + SF_FORMTYPE(LGDI); + + ~BGSLegendaryItem() override; // 00 + + // members + TESLevItem* applicableItemList; // 150 + BGSLegendaryItem* legendaryTemplate; // 158 + BSTArray unk160[3]; // 160 + }; + static_assert(sizeof(BGSLegendaryItem) == 0x190); +} diff --git a/CommonLibSF/include/RE/B/BGSNavmeshableObject.h b/CommonLibSF/include/RE/B/BGSNavmeshableObject.h new file mode 100644 index 00000000..8ab62328 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSNavmeshableObject.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/N/NiSmartPointer.h" + +namespace RE +{ + class NavMesh; + + class BGSNavmeshableObject + { + public: + SF_RTTI(BGSNavmeshableObject); + + // members + NiPointer embeddableNavmesh; // 00 - BSTSmartPointer in FO4 + }; + static_assert(sizeof(BGSNavmeshableObject) == 0x8); +} diff --git a/CommonLibSF/include/RE/B/BGSOpenCloseForm.h b/CommonLibSF/include/RE/B/BGSOpenCloseForm.h new file mode 100644 index 00000000..4ae00be2 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSOpenCloseForm.h @@ -0,0 +1,21 @@ +#pragma once + +namespace RE +{ + class TESObjectREFR; + + class BGSOpenCloseForm + { + public: + SF_RTTI(BGSOpenCloseForm); + + virtual ~BGSOpenCloseForm(); // 00 + + // add + virtual void HandleOpenStart(TESObjectREFR* a_target, TESObjectREFR* a_activator, bool a_arg3); // 01 + virtual void HandleCloseStart(TESObjectREFR* a_target, TESObjectREFR* a_activator, bool a_arg3); // 02 + virtual void HandleOpenFinish(TESObjectREFR* a_target, TESObjectREFR* a_activator); // 03 + virtual void HandleCloseFinish(TESObjectREFR* a_target, TESObjectREFR* a_activator); // 04 + }; + static_assert(sizeof(BGSOpenCloseForm) == 0x8); +} diff --git a/CommonLibSF/include/RE/B/BGSPackIn.h b/CommonLibSF/include/RE/B/BGSPackIn.h new file mode 100644 index 00000000..35b21a18 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSPackIn.h @@ -0,0 +1,38 @@ +#pragma once + +#include "RE/B/BGSForcedLocRefType.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSNativeTerminalForm.h" +#include "RE/B/BGSPreviewTransform.h" +#include "RE/B/BGSPropertySheet.h" +#include "RE/B/BSStringT.h" +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class BGSLayeredMaterialSwap; + class TESObjectCELL; + + class BGSPackIn : + public TESBoundObject, // 000 + public BGSKeywordForm, // 118 + public BGSPropertySheet, // 148 + public BGSPreviewTransform, // 158 + public BGSForcedLocRefType, // 1A0 + public BGSNativeTerminalForm // 1B8 + { + public: + SF_RTTI_VTABLE(BGSPackIn); + SF_FORMTYPE(PKIN); + + ~BGSPackIn() override; // 00 + + // members + TESObjectCELL* cell; // 1C8 + std::uint32_t flags; // 1D0 + BSStringT filter; // 1D4 + BSTArray materialSwaps; // 1E8 + std::uint32_t unk1F8; // 1F8 + }; + static_assert(sizeof(BGSPackIn) == 0x200); +} diff --git a/CommonLibSF/include/RE/B/BGSProjectedDecal.h b/CommonLibSF/include/RE/B/BGSProjectedDecal.h new file mode 100644 index 00000000..f3434c09 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSProjectedDecal.h @@ -0,0 +1,35 @@ +#pragma once + +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class BGSMaterialPathForm; + + class BGSProjectedDecal : public TESBoundObject + { + public: + SF_RTTI_VTABLE(BGSProjectedDecal); + SF_FORMTYPE(PDCL); + + struct Data + { + public: + // members + float unk00; // 00 + float unk04; // 04 + float unk08; // 08 + float unk0C; // 0C + float unk10; // 10 + float unk14; // 14 + }; + static_assert(sizeof(Data) == 0x18); + + ~BGSProjectedDecal() override; // 00 + + // members + BGSMaterialPathForm* material; // 118 + Data data; // 120 + }; + static_assert(sizeof(BGSProjectedDecal) == 0x138); +} diff --git a/CommonLibSF/include/RE/B/BGSStaticCollection.h b/CommonLibSF/include/RE/B/BGSStaticCollection.h new file mode 100644 index 00000000..1e771a34 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSStaticCollection.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/N/NiSmartPointer.h" +#include "RE/T/TESBoundObject.h" + +namespace RE +{ + class Navmesh; + + class BGSStaticCollection : + public TESBoundObject, // 000 + public BGSModelMaterialSwap // 118 + { + public: + SF_RTTI_VTABLE(BGSStaticCollection); + SF_FORMTYPE(SCOL); + + ~BGSStaticCollection() override; // 00 + + // members + NiPointer navmesh; // 140 + std::uint64_t unk148; // 148 - BSTHashMap* + }; + static_assert(sizeof(BGSStaticCollection) == 0x150); +} diff --git a/CommonLibSF/include/RE/B/BGSTextureSet.h b/CommonLibSF/include/RE/B/BGSTextureSet.h new file mode 100644 index 00000000..10179c72 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSTextureSet.h @@ -0,0 +1,48 @@ +#pragma once + +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESTexture.h" + +namespace RE +{ + class DecalData; + + namespace TextureUtils + { + struct TextureId + { + public: + // members + std::uint32_t unk0; // 0 + std::uint32_t unk4; // 4 + std::uint32_t unk8; // 8 + }; + static_assert(sizeof(TextureId) == 0xC); + + struct TextureIdSet + { + public: + // members + TextureId textureIDs[31]; // 00 + }; + static_assert(sizeof(TextureIdSet) == 0x174); + } + + class BGSTextureSet : + public TESBoundObject, // 000 + public TextureUtils::TextureIdSet // 118 + { + public: + SF_RTTI_VTABLE(BGSTextureSet); + SF_FORMTYPE(TXST); + + ~BGSTextureSet() override; // 00 + + // members + BSFixedString materialName; // 290 + TESTexture textures[19]; // 298 + DecalData* decalData; // 3C8 + std::uint16_t flags; // 3D0 + }; + static_assert(sizeof(BGSTextureSet) == 0x3D8); +} diff --git a/CommonLibSF/include/RE/E/EffectArchetypes.h b/CommonLibSF/include/RE/E/EffectArchetypes.h new file mode 100644 index 00000000..b80bc46c --- /dev/null +++ b/CommonLibSF/include/RE/E/EffectArchetypes.h @@ -0,0 +1,66 @@ +#pragma once + +namespace RE +{ + struct EffectArchetypes + { + enum class ArchetypeID + { + kNone = static_cast>(-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, + kParalysis = 21, + kReanimate = 22, + kSoulTrap = 23, + kTurnUndead = 24, + kGuide = 25, + kSummonDuplicate = 26, + kCureParalysis = 27, + kCureAddiction = 28, + kCurePoison = 29, + kConcussion = 30, + kStimpak = 31, + kAccumulatingMagnitude = 32, + kStagger = 33, + kPeakValueModifier = 34, + kCloak = 35, + kCommand = 36, + kSlowTime = 37, + kRally = 38, + kEnhanceWeapon = 39, + kSpawnHazard = 40, + kEtherealize = 41, + kBanish = 42, + kSpawnScriptedRef = 43, + kDisguise = 44, + kDamage = 45, + kImmunity = 46, + kPermanentReanimate = 47, + kBoostpack = 48, + kChameleon = 49, + kCapacityValueModifier = 50, + kResetFlora = 51, + kDropResources = 52, + kAntigravity = 53, + }; + }; +} diff --git a/CommonLibSF/include/RE/E/EffectItem.h b/CommonLibSF/include/RE/E/EffectItem.h index 71110f49..61bcde50 100644 --- a/CommonLibSF/include/RE/E/EffectItem.h +++ b/CommonLibSF/include/RE/E/EffectItem.h @@ -1,5 +1,7 @@ #pragma once +#include "RE/T/TESCondition.h" + namespace RE { class EffectSetting; @@ -27,7 +29,7 @@ namespace RE std::uint32_t unk30; // 30 std::uint32_t unk34; // 34 float rawCost; // 38 - std::uint64_t conditions[2]; // 40 - TESCondition + TESCondition conditions; // 40 }; static_assert(sizeof(EffectItem) == 0x50); } diff --git a/CommonLibSF/include/RE/E/EffectSetting.h b/CommonLibSF/include/RE/E/EffectSetting.h new file mode 100644 index 00000000..003ff193 --- /dev/null +++ b/CommonLibSF/include/RE/E/EffectSetting.h @@ -0,0 +1,119 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLocalizedString.h" +#include "RE/B/BGSMenuDisplayObject.h" +#include "RE/B/BSTArray.h" +#include "RE/E/EffectArchetypes.h" +#include "RE/M/MagicSystem.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class ActorValueInfo; + class BGSArtObject; + class BGSDualCastData; + class BGSExplosion; + class BGSImpactDataSet; + class BGSPerk; + class BGSProjectile; + class EffectShader; + class SpellItem; + class TESImageSpaceModifier; + class TESObjectLIGH; + + class EffectSetting : + public TESForm, // 000 + public TESFullName, // 038 + public BGSMenuDisplayObject, // 048 + public BGSKeywordForm // 058 + { + public: + SF_RTTI_VTABLE(EffectSetting); + SF_FORMTYPE(MGEF); + + using FilterValidationFunction_t = bool(EffectSetting*, void*); + + struct 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 + TESForm* associatedForm; // 00 + ActorValueInfo* associatedSkill; // 08 + BGSArtObject* castingArt; // 10 + BGSDualCastData* dualCastData; // 18 + EffectShader* effectShader; // 20 + EffectShader* enchantShader; // 28 + BGSArtObject* enchantEffectArt; // 30 + SpellItem* equipAbility; // 38 + BGSExplosion* explosion; // 40 + BGSArtObject* hitEffectArt; // 48 + TESImageSpaceModifier* imageSpaceMod; // 50 + BGSImpactDataSet* impactDataSet; // 58 + TESObjectLIGH* light; // 60 + BGSPerk* perk; // 68 + ActorValueInfo* primaryAV; // 70 + BGSProjectile* projectile; // 78 + ActorValueInfo* resistVariable; // 80 + ActorValueInfo* secondaryAV; // 88 + float baseCost; // 90 + float taperWeight; // 94 + std::uint32_t spellMakingArea; // 98 + float spellMakingChargeTime; // 9C + float taperCurve; // A0 + float taperDuration; // A4 + float secondaryAVWeight; // A8 + float skillUsageMult; // AC + float dualCastScale; // B0 + float unkB4; // B4 + float unkB8; // B8 + std::uint32_t minimumSkill; // BC + stl::enumeration flags; // C0 + stl::enumeration archetype; // C4 + stl::enumeration castingType; // C8 + stl::enumeration deliveryType; // C9 + std::uint32_t unkCC; // CC + }; + static_assert(sizeof(EffectSettingData) == 0xD0); + + ~EffectSetting() override; // 00 + + // members + FilterValidationFunction_t* filterValidationFunction; // 088 + void* filterValidationItem; // 090 + EffectSettingData data; // 098 + BSTArray unk168; // 168 + std::uint8_t unk178[0x48]; // 178 - ESSH + std::uint64_t unk1C0; // 1C0 + std::uint64_t unk1C8; // 1C8 + BGSLocalizedString magicItemDescription; // 1D0 + std::uint64_t unk1D8; // 1D8 + TESCondition conditions; // 1E0 + }; + static_assert(sizeof(EffectSetting) == 0x1F0); +} diff --git a/CommonLibSF/include/RE/E/EnchantmentItem.h b/CommonLibSF/include/RE/E/EnchantmentItem.h new file mode 100644 index 00000000..d6ab3651 --- /dev/null +++ b/CommonLibSF/include/RE/E/EnchantmentItem.h @@ -0,0 +1,34 @@ +#pragma once + +#include "RE/M/MagicItem.h" + +namespace RE +{ + class BGSListForm; + + class EnchantmentItem : public MagicItem + { + public: + SF_RTTI_VTABLE(EnchantmentItem); + SF_FORMTYPE(ENCH); + + class Data : + public MagicItem::Data // 00 + { + public: + // members + stl::enumeration castingType; // 00 + std::uint32_t chargeOverride; // 0C + stl::enumeration delivery; // 10 + stl::enumeration spellType; // 11 + float chargeTime; // 14 + EnchantmentItem* baseEnchantment; // 18 + BGSListForm* wornRestrictions; // 20 + }; + static_assert(sizeof(Data) == 0x28); + + // members + Data data; // 188 + }; + static_assert(sizeof(EnchantmentItem) == 0x1B0); +} diff --git a/CommonLibSF/include/RE/N/NiColor.h b/CommonLibSF/include/RE/N/NiColor.h new file mode 100644 index 00000000..23b2918e --- /dev/null +++ b/CommonLibSF/include/RE/N/NiColor.h @@ -0,0 +1,412 @@ +#pragma once + +namespace RE +{ + class NiColor; + class NiColorA; + + class NiColor + { + public: + enum : std::size_t + { + kRed, + kGreen, + kBlue, + + kTotal + }; + + constexpr NiColor() noexcept {} + + constexpr NiColor(const NiColor& a_rhs) noexcept : + red(a_rhs.red), + green(a_rhs.green), + blue(a_rhs.blue) + {} + + constexpr NiColor(NiColor&& a_rhs) noexcept : + red(std::move(a_rhs.red)), + green(std::move(a_rhs.green)), + blue(std::move(a_rhs.blue)) + {} + + constexpr NiColor(float a_red, float a_green, float a_blue) noexcept : + red(a_red), + green(a_green), + blue(a_blue) + {} + + constexpr NiColor(std::uint32_t a_hexValue) noexcept : + red(((a_hexValue >> 16) & 0xFF) / 255.0f), + green(((a_hexValue >> 8) & 0xFF) / 255.0f), + blue(((a_hexValue)&0xFF) / 255.0f) + { + } + + ~NiColor() noexcept = default; + + constexpr NiColor& operator=(const NiColor& a_rhs) noexcept + { + if (this != std::addressof(a_rhs)) { + red = a_rhs.red; + green = a_rhs.green; + blue = a_rhs.blue; + } + return *this; + } + + constexpr NiColor& operator=(NiColor&& a_rhs) noexcept + { + if (this != std::addressof(a_rhs)) { + red = std::move(a_rhs.red); + green = std::move(a_rhs.green); + blue = std::move(a_rhs.blue); + } + return *this; + } + + constexpr NiColor& operator=(const NiColorA& a_rhs) noexcept; + + [[nodiscard]] friend constexpr bool operator==(const NiColor& a_lhs, const NiColor& a_rhs) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + if (a_lhs[i] != a_rhs[i]) { + return false; + } + } + return true; + } + + [[nodiscard]] friend constexpr bool operator!=(const NiColor& a_lhs, const NiColor& a_rhs) noexcept + { + return !(a_lhs == a_rhs); + } + + [[nodiscard]] constexpr float& operator[](std::size_t a_idx) noexcept + { + assert(a_idx < kTotal); + return std::addressof(red)[a_idx]; + } + + [[nodiscard]] constexpr const float& operator[](std::size_t a_idx) const noexcept + { + assert(a_idx < kTotal); + return std::addressof(red)[a_idx]; + } + + [[nodiscard]] NiColor operator+(const NiColor& a_rhs) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] += a_rhs[i]; + } + return tmp; + } + + NiColor& operator+=(const NiColor& a_rhs) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) += a_rhs[i]; + } + return *this; + } + + [[nodiscard]] NiColor operator-(const NiColor& a_rhs) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] -= a_rhs[i]; + } + return tmp; + } + + NiColor& operator-=(const NiColor& a_rhs) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) -= a_rhs[i]; + } + return *this; + } + + friend NiColor operator-(float a_lhs, const NiColor& a_rhs) + { + return NiColor( + a_lhs - a_rhs.red, + a_lhs - a_rhs.green, + a_lhs - a_rhs.blue); + } + + [[nodiscard]] NiColor operator*(const NiColor& a_rhs) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] *= a_rhs[i]; + } + return tmp; + } + + NiColor& operator*=(const NiColor& a_rhs) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) *= a_rhs[i]; + } + return *this; + } + + friend NiColor operator*(float a_lhs, const NiColor& a_rhs) + { + return NiColor( + a_lhs * a_rhs.red, + a_lhs * a_rhs.green, + a_lhs * a_rhs.blue); + } + + [[nodiscard]] NiColor operator/(const NiColor& a_rhs) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] /= a_rhs[i]; + } + return tmp; + } + + NiColor& operator/=(const NiColor& a_rhs) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) /= a_rhs[i]; + } + return *this; + } + + friend NiColor operator/(float a_lhs, const NiColor& a_rhs) + { + return NiColor( + a_lhs / a_rhs.red, + a_lhs / a_rhs.green, + a_lhs / a_rhs.blue); + } + + [[nodiscard]] NiColor operator+(float a_value) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] += a_value; + } + return tmp; + } + + NiColor& operator+=(float a_value) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) += a_value; + } + return *this; + } + + [[nodiscard]] NiColor operator-(float a_value) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] -= a_value; + } + return tmp; + } + + NiColor& operator-=(float a_value) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) -= a_value; + } + return *this; + } + + [[nodiscard]] NiColor operator*(float a_value) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] *= a_value; + } + return tmp; + } + + NiColor& operator*=(float a_value) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) *= a_value; + } + return *this; + } + + [[nodiscard]] NiColor operator/(float a_value) const noexcept + { + NiColor tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] /= a_value; + } + return tmp; + } + + NiColor& operator/=(float a_value) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) /= a_value; + } + return *this; + } + + // members + float red{ 0.0f }; // 0 + float green{ 0.0f }; // 4 + float blue{ 0.0f }; // 8 + }; + static_assert(sizeof(NiColor) == 0xC); + + class NiColorA + { + public: + enum : std::size_t + { + kRed, + kGreen, + kBlue, + kAlpha, + + kTotal + }; + + constexpr NiColorA() noexcept {} + + constexpr NiColorA(const NiColorA& a_rhs) noexcept : + red(a_rhs.red), + green(a_rhs.green), + blue(a_rhs.blue), + alpha(a_rhs.alpha) + {} + + constexpr NiColorA(NiColorA&& a_rhs) noexcept : + red(std::move(a_rhs.red)), + green(std::move(a_rhs.green)), + blue(std::move(a_rhs.blue)), + alpha(std::move(a_rhs.alpha)) + {} + + constexpr NiColorA(float a_red, float a_green, float a_blue, float a_alpha) noexcept : + red(a_red), + green(a_green), + blue(a_blue), + alpha(a_alpha) + {} + + ~NiColorA() noexcept = default; + + constexpr NiColorA& operator=(const NiColorA& a_rhs) noexcept + { + if (this != std::addressof(a_rhs)) { + red = a_rhs.red; + green = a_rhs.green; + blue = a_rhs.blue; + alpha = a_rhs.alpha; + } + return *this; + } + + constexpr NiColorA& operator=(NiColorA&& a_rhs) noexcept + { + if (this != std::addressof(a_rhs)) { + red = std::move(a_rhs.red); + green = std::move(a_rhs.green); + blue = std::move(a_rhs.blue); + alpha = std::move(a_rhs.alpha); + } + return *this; + } + + constexpr NiColorA& operator=(const NiColor& a_rhs) noexcept; + + [[nodiscard]] friend constexpr bool operator==(const NiColorA& a_lhs, const NiColorA& a_rhs) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + if (a_lhs[i] != a_rhs[i]) { + return false; + } + } + return true; + } + + [[nodiscard]] friend constexpr bool operator!=(const NiColorA& a_lhs, const NiColorA& a_rhs) noexcept + { + return !(a_lhs == a_rhs); + } + + [[nodiscard]] constexpr float& operator[](std::size_t a_idx) noexcept + { + assert(a_idx < kTotal); + return std::addressof(red)[a_idx]; + } + + [[nodiscard]] constexpr const float& operator[](std::size_t a_idx) const noexcept + { + assert(a_idx < kTotal); + return std::addressof(red)[a_idx]; + } + + [[nodiscard]] NiColorA operator*(float a_value) const noexcept + { + NiColorA tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] *= a_value; + } + return tmp; + } + + NiColorA& operator*=(float a_value) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) *= a_value; + } + return *this; + } + + [[nodiscard]] NiColorA operator/(float a_value) const noexcept + { + NiColorA tmp = *this; + for (std::size_t i = 0; i < kTotal; ++i) { + tmp[i] /= a_value; + } + return tmp; + } + + NiColorA& operator/=(float a_value) noexcept + { + for (std::size_t i = 0; i < kTotal; ++i) { + operator[](i) /= a_value; + } + return *this; + } + + // members + float red{ 0.0f }; // 00 + float green{ 0.0f }; // 04 + float blue{ 0.0f }; // 08 + float alpha{ 0.0f }; // 0C + }; + static_assert(sizeof(NiColorA) == 0x10); + + constexpr NiColor& NiColor::operator=(const NiColorA& a_rhs) noexcept + { + red = a_rhs.red; + green = a_rhs.green; + blue = a_rhs.blue; + return *this; + } + + constexpr NiColorA& NiColorA::operator=(const NiColor& a_rhs) noexcept + { + red = a_rhs.red; + green = a_rhs.green; + blue = a_rhs.blue; + alpha = 0.0; + return *this; + } +} diff --git a/CommonLibSF/include/RE/N/NiPoint4.h b/CommonLibSF/include/RE/N/NiPoint4.h new file mode 100644 index 00000000..7757867f --- /dev/null +++ b/CommonLibSF/include/RE/N/NiPoint4.h @@ -0,0 +1,27 @@ +#pragma once + +namespace RE +{ + class NiPoint4 + { + public: + struct NiPoint4Struct + { + public: + // members + float x; // 00 + float y; // 04 + float z; // 08 + float w; // 0C + }; + static_assert(sizeof(NiPoint4Struct) == 0x10); + + // members + union + { + NiPoint4Struct v; + float pt[4]{ 0.0F }; + }; // 00 + }; + static_assert(sizeof(NiPoint4) == 0x10); +} diff --git a/CommonLibSF/include/RE/P/Projectile.h b/CommonLibSF/include/RE/P/Projectile.h index 9315a9b3..c554b034 100644 --- a/CommonLibSF/include/RE/P/Projectile.h +++ b/CommonLibSF/include/RE/P/Projectile.h @@ -17,6 +17,7 @@ namespace RE class bhkNPCollisionObject; class ActorCause; + class AlchemyItem; class BGSExplosion; class BGSMaterialType; class BGSProjectile; diff --git a/CommonLibSF/include/RE/Starfield.h b/CommonLibSF/include/RE/Starfield.h index d93dfa9a..c0b1787d 100644 --- a/CommonLibSF/include/RE/Starfield.h +++ b/CommonLibSF/include/RE/Starfield.h @@ -3,6 +3,7 @@ #include "SFSE/Impl/PCH.h" #include "RE/A/AIProcess.h" +#include "RE/A/AVMData.h" #include "RE/A/Actor.h" #include "RE/A/ActorEquipManager.h" #include "RE/A/ActorPackage.h" @@ -11,11 +12,17 @@ #include "RE/A/ActorValueOwner.h" #include "RE/A/ActorValueStorage.h" #include "RE/A/ActorValues.h" +#include "RE/A/AlchemyItem.h" #include "RE/A/Array.h" #include "RE/A/ArrowProjectile.h" +#include "RE/B/BGSAcousticSpace.h" #include "RE/B/BGSAnimationGraphComponent.h" +#include "RE/B/BGSArtObject.h" #include "RE/B/BGSAttachParentArray.h" #include "RE/B/BGSAttackDataForm.h" +#include "RE/B/BGSAudioOcclusionPrimitive.h" +#include "RE/B/BGSBendableSpline.h" +#include "RE/B/BGSBiomeMarkerObject.h" #include "RE/B/BGSBipedObjectForm.h" #include "RE/B/BGSBlockBashData.h" #include "RE/B/BGSBodyPartDefs.h" @@ -28,15 +35,21 @@ #include "RE/B/BGSEquipIndex.h" #include "RE/B/BGSEquipSlot.h" #include "RE/B/BGSEquipType.h" +#include "RE/B/BGSExplosion.h" #include "RE/B/BGSFeaturedItemMessage.h" #include "RE/B/BGSForcedLocRefType.h" #include "RE/B/BGSFormFolderKeywordList.h" +#include "RE/B/BGSGenericBaseForm.h" +#include "RE/B/BGSHazard.h" +#include "RE/B/BGSIdleCollection.h" +#include "RE/B/BGSIdleMarker.h" #include "RE/B/BGSInstanceNamingRulesForm.h" #include "RE/B/BGSInventoryInterface.h" #include "RE/B/BGSInventoryItem.h" #include "RE/B/BGSInventoryList.h" #include "RE/B/BGSKeyword.h" #include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLegendaryItem.h" #include "RE/B/BGSListForm.h" #include "RE/B/BGSLocalizedString.h" #include "RE/B/BGSLocalizedStringDL.h" @@ -46,24 +59,30 @@ #include "RE/B/BGSMod.h" #include "RE/B/BGSModelMaterialSwap.h" #include "RE/B/BGSNativeTerminalForm.h" +#include "RE/B/BGSNavmeshableObject.h" #include "RE/B/BGSObjectInstance.h" #include "RE/B/BGSObjectPlacementDefaults.h" +#include "RE/B/BGSOpenCloseForm.h" #include "RE/B/BGSOutfit.h" #include "RE/B/BGSOverridePackCollection.h" +#include "RE/B/BGSPackIn.h" #include "RE/B/BGSPerk.h" #include "RE/B/BGSPerkRankArray.h" #include "RE/B/BGSPickupPutdownSounds.h" #include "RE/B/BGSPreloadable.h" #include "RE/B/BGSPreviewTransform.h" +#include "RE/B/BGSProjectedDecal.h" #include "RE/B/BGSProjectile.h" #include "RE/B/BGSPropertySheet.h" #include "RE/B/BGSReflectedForm.h" #include "RE/B/BGSScene.h" #include "RE/B/BGSSkinForm.h" #include "RE/B/BGSSnapTemplateComponent.h" +#include "RE/B/BGSStaticCollection.h" #include "RE/B/BGSTerminal.h" #include "RE/B/BGSTerminalMenu.h" #include "RE/B/BGSTextureModel.h" +#include "RE/B/BGSTextureSet.h" #include "RE/B/BGSTypedFormValuePair.h" #include "RE/B/BGSTypedKeywordValueArray.h" #include "RE/B/BGSVoiceType.h" @@ -97,8 +116,11 @@ #include "RE/C/Console.h" #include "RE/C/ConsoleLog.h" #include "RE/D/DebuggerMessages.h" +#include "RE/E/EffectArchetypes.h" #include "RE/E/EffectItem.h" +#include "RE/E/EffectSetting.h" #include "RE/E/EmitterProjectile.h" +#include "RE/E/EnchantmentItem.h" #include "RE/E/ErrorLogger.h" #include "RE/E/ExtraDataList.h" #include "RE/E/ExtraDataTypes.h" @@ -153,8 +175,10 @@ #include "RE/M/msvc.h" #include "RE/N/NativeFunction.h" #include "RE/N/NativeFunctionBase.h" +#include "RE/N/NiColor.h" #include "RE/N/NiMatrix3.h" #include "RE/N/NiPoint3.h" +#include "RE/N/NiPoint4.h" #include "RE/N/NiSmartPointer.h" #include "RE/N/NiTransform.h" #include "RE/O/Object.h" @@ -196,12 +220,14 @@ #include "RE/T/TESAIForm.h" #include "RE/T/TESActorBase.h" #include "RE/T/TESActorBaseData.h" +#include "RE/T/TESAmmo.h" #include "RE/T/TESBipedModelForm.h" #include "RE/T/TESBoundAnimObject.h" #include "RE/T/TESBoundObject.h" #include "RE/T/TESCamera.h" #include "RE/T/TESCellFullyLoadedEvent.h" #include "RE/T/TESClass.h" +#include "RE/T/TESCondition.h" #include "RE/T/TESContainer.h" #include "RE/T/TESContainerChangedEvent.h" #include "RE/T/TESDataHandler.h" @@ -213,16 +239,27 @@ #include "RE/T/TESFormRefCount.h" #include "RE/T/TESFullName.h" #include "RE/T/TESGlobal.h" +#include "RE/T/TESGrass.h" #include "RE/T/TESHandleForm.h" #include "RE/T/TESKey.h" +#include "RE/T/TESMagicTargetForm.h" #include "RE/T/TESModel.h" #include "RE/T/TESNPC.h" #include "RE/T/TESObject.h" +#include "RE/T/TESObjectACTI.h" +#include "RE/T/TESObjectANIO.h" +#include "RE/T/TESObjectARMA.h" #include "RE/T/TESObjectARMO.h" +#include "RE/T/TESObjectBOOK.h" #include "RE/T/TESObjectCELL.h" +#include "RE/T/TESObjectCONT.h" +#include "RE/T/TESObjectDOOR.h" +#include "RE/T/TESObjectLIGH.h" #include "RE/T/TESObjectLoadedEvent.h" #include "RE/T/TESObjectMISC.h" #include "RE/T/TESObjectREFR.h" +#include "RE/T/TESObjectSTAT.h" +#include "RE/T/TESObjectWEAP.h" #include "RE/T/TESQuest.h" #include "RE/T/TESRace.h" #include "RE/T/TESRaceForm.h" diff --git a/CommonLibSF/include/RE/T/TESAmmo.h b/CommonLibSF/include/RE/T/TESAmmo.h new file mode 100644 index 00000000..6e875c44 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESAmmo.h @@ -0,0 +1,60 @@ +#pragma once + +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLocalizedString.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSPickupPutdownSounds.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESDescription.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESValueForm.h" +#include "RE/T/TESWeightForm.h" + +namespace RE +{ + class BGSProjectile; + + struct AMMO_DATA + { + public: + enum class Flag + { + kNone = 0, + kIgnoresNormalWeaponResistance = 1 << 0, + kNonPlayable = 1 << 1, + kHasCountBased3D = 1 << 2 + }; + + // members + BGSProjectile* projectile; // 00 + std::uint32_t health; // 08 + float damage; // 0C + stl::enumeration flags; // 10 + }; + static_assert(sizeof(AMMO_DATA) == 0x18); + + class TESAmmo : + public TESBoundObject, // 000 + public TESFullName, // 118 + public BGSModelMaterialSwap, // 128 + public TESValueForm, // 150 + public BGSDestructibleObjectForm, // 160 + public BGSPickupPutdownSounds, // 170 + public TESDescription, // 1D8 + public BGSKeywordForm, // 1F0 + public TESWeightForm // 220 + { + public: + SF_RTTI_VTABLE(TESAmmo); + SF_FORMTYPE(AMMO); + + ~TESAmmo() override; // 00 + + // members + AMMO_DATA data; // 230 + BGSLocalizedString shortDesc; // 248 + TESModel shellCasing; // 250 + }; + static_assert(sizeof(TESAmmo) == 0x270); +} diff --git a/CommonLibSF/include/RE/T/TESCondition.h b/CommonLibSF/include/RE/T/TESCondition.h new file mode 100644 index 00000000..cd741cb4 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESCondition.h @@ -0,0 +1,15 @@ +#pragma once + +namespace RE +{ + class TESConditionItem; + + class TESCondition + { + public: + // members + std::uint8_t unk0; // 0 + TESConditionItem* head; // 8 + }; + static_assert(sizeof(TESCondition) == 0x10); +} diff --git a/CommonLibSF/include/RE/T/TESGrass.h b/CommonLibSF/include/RE/T/TESGrass.h new file mode 100644 index 00000000..cd1c7599 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESGrass.h @@ -0,0 +1,75 @@ +#pragma once + +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESModel.h" + +namespace RE +{ + class TESGrass : + public TESBoundObject, // 00 + public TESModel // 30 + { + public: + SF_RTTI_VTABLE(TESGrass); + SF_FORMTYPE(GRAS); + + struct GRASS_DATA // DATA + { + enum class Flag + { + kNone = 0, + kVertexLighting = 1 << 0, + kUniformScale = 1 << 1, + kFitSlope = 1 << 2 + }; + + std::uint32_t unk00; // 00 + float unk04; // 04 - heightRange? + float unk08; // 08 - positionRange? + float wavePeriod; // 0C + std::uint32_t unk10; // 10 + std::uint32_t unk14; // 14 + std::uint32_t unk18; // 18 + std::uint32_t unk1C; // 1C + std::uint8_t density; // 20 + std::uint8_t minSlope; // 21 + std::uint8_t maxSlope; // 22 + stl::enumeration flags; // 23 + std::uint8_t unk24; // 24 + std::uint8_t unk25; // 25 + }; + static_assert(sizeof(GRASS_DATA) == 0x28); + + ~TESGrass() override; // 00 + + // add + virtual std::uint8_t GetDensity() const; // 82 + virtual bool SetDensity(std::uint8_t a_density); // 83 + virtual std::uint8_t GetMinSlopeDegrees() const; // 84 + virtual bool SetMinSlopeDegrees(std::uint8_t a_minSlope); // 85 + virtual std::uint8_t GetMaxSlopeDegrees() const; // 86 + virtual bool SetMaxSlopeDegrees(std::uint8_t a_maxSlope); // 87 + virtual float GetMinSlope() const; // 88 + virtual float GetMaxSlope() const; // 89 + virtual void Unk_8A(); // 8A + virtual void Unk_8B(); // 8B + virtual void Unk_8C(); // 8C + virtual void Unk_8D(); // 8D + virtual float GetWavePeriod() const; // 8E + virtual bool SetWavePeriod(float a_wavePeriod); // 8F + virtual void Unk_90(); // 90 + virtual void Unk_91(); // 91 + virtual void Unk_92(); // 92 + virtual void Unk_93(); // 93 + virtual bool GetVertexLighting() const; // 94 + virtual void SetVertexLighting(bool a_set); // 95 + virtual bool GetUniformScaling() const; // 96 + virtual void SetUniformScaling(bool a_set); // 97 + virtual bool GetFitToSlope() const; // 98 + virtual void SetFitToSlope(bool a_set); // 99 + + // members + GRASS_DATA data; // 138 - DATA + }; + static_assert(sizeof(TESGrass) == 0x160); +} diff --git a/CommonLibSF/include/RE/T/TESMagicTargetForm.h b/CommonLibSF/include/RE/T/TESMagicTargetForm.h new file mode 100644 index 00000000..bc5400ce --- /dev/null +++ b/CommonLibSF/include/RE/T/TESMagicTargetForm.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BaseFormComponent.h" + +namespace RE +{ + class TESMagicTargetForm : public BaseFormComponent + { + public: + SF_RTTI_VTABLE(TESMagicTargetForm); + + ~TESMagicTargetForm() override; // 00 + + // override (BaseFormComponent) + const BSFixedString& GetFormComponentType() const override; // 01 - { return "TESMagicTargetForm_Component"; } + void InitializeDataComponent() override; // 02 - { return; } + }; + static_assert(sizeof(TESMagicTargetForm) == 0x8); +} diff --git a/CommonLibSF/include/RE/T/TESNPC.h b/CommonLibSF/include/RE/T/TESNPC.h index 3882baba..6e6e8591 100644 --- a/CommonLibSF/include/RE/T/TESNPC.h +++ b/CommonLibSF/include/RE/T/TESNPC.h @@ -1,12 +1,13 @@ #pragma once +#include "RE/A/AVMData.h" #include "RE/B/BGSAttachParentArray.h" #include "RE/B/BGSForcedLocRefType.h" #include "RE/B/BGSNativeTerminalForm.h" #include "RE/B/BGSOverridePackCollection.h" +#include "RE/B/BSLock.h" #include "RE/B/BSTArray.h" #include "RE/B/BSTEvent.h" -#include "RE/C/Color.h" #include "RE/N/NiPoint3.h" #include "RE/S/Sexes.h" #include "RE/T/TESActorBase.h" @@ -44,18 +45,6 @@ namespace RE kTheyThem }; - struct TintData - { - std::uint32_t type; // 00 - std::uint32_t unk04; // 04 - BSFixedString category; // 08 - BSFixedString name; // 10 - BSFixedString texturePath; // 18 - Color color; // 20 - std::uint32_t intensity; // 24 - }; - static_assert(sizeof(TintData) == 0x28); - ~TESNPC() override; // 00 [[nodiscard]] TESRace* GetRace() const { return formRace; } @@ -93,11 +82,11 @@ namespace RE TESFaction* crimeFaction; // 3E0 TESFaction* unk3E8; // 3E8 BSTArray headparts; // 3F0 - std::uint64_t unk400; // 400 + BSNonReentrantSpinLock headpartsLock; // 3F8 BSTArray* unk408; // 408 std::uint64_t unk410; // 410 std::uint64_t unk418; // 418 - BSTArray tintData; // 420 + BSTArray tintAVMData; // 420 std::uint32_t skinToneIndex; // 430 std::uint32_t unk434; // 434 BSFixedString teeth; // 438 diff --git a/CommonLibSF/include/RE/T/TESObject.h b/CommonLibSF/include/RE/T/TESObject.h index e22e6be5..e25cdd13 100644 --- a/CommonLibSF/include/RE/T/TESObject.h +++ b/CommonLibSF/include/RE/T/TESObject.h @@ -18,7 +18,7 @@ namespace RE virtual void SetAutoCalc(bool a_autoCalc); // 65 virtual void Unk_66(); // 66 virtual void Unk_67(); // 67 - virtual void Unk_68(); // 68 + virtual bool IsMarker(); // 68 virtual void Unk_69(); // 69 virtual void Unk_6A(); // 6A virtual void Unk_6B(); // 6B diff --git a/CommonLibSF/include/RE/T/TESObjectACTI.h b/CommonLibSF/include/RE/T/TESObjectACTI.h new file mode 100644 index 00000000..19c757d6 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectACTI.h @@ -0,0 +1,49 @@ +#pragma once + +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSForcedLocRefType.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSNativeTerminalForm.h" +#include "RE/B/BGSNavmeshableObject.h" +#include "RE/B/BGSOpenCloseForm.h" +#include "RE/B/BGSPropertySheet.h" +#include "RE/T/TESBoundAnimObject.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESMagicTargetForm.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class TESWaterForm; + + class TESObjectACTI : + public TESBoundAnimObject, // 000 + public TESFullName, // 118 + public BGSModelMaterialSwap, // 128 + public TESMagicTargetForm, // 150 + public BGSDestructibleObjectForm, // 158 + public BGSOpenCloseForm, // 168 + public BGSKeywordForm, // 170 + public BGSPropertySheet, // 1A0 + public BGSForcedLocRefType, // 1B0 + public BGSNativeTerminalForm, // 1C8 + public BGSNavmeshableObject // 1D8 + { + public: + SF_RTTI_VTABLE(TESObjectACTI); + SF_FORMTYPE(ACTI); + + ~TESObjectACTI() override; // 00 + + // members + BGSAudio::WwiseSoundHook soundLoop; // 1E0 + BGSAudio::WwiseSoundHook soundActivate; // 210 + TESWaterForm* waterForm; // 240 + std::uint32_t unk248; // 248 + std::uint16_t flags; // 24C + std::uint16_t activationAngle; // 24E + std::uint8_t unk250; // 250 + }; + static_assert(sizeof(TESObjectACTI) == 0x258); +} diff --git a/CommonLibSF/include/RE/T/TESObjectANIO.h b/CommonLibSF/include/RE/T/TESObjectANIO.h new file mode 100644 index 00000000..a894a771 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectANIO.h @@ -0,0 +1,23 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESObjectANIO : + public TESForm, // 00 + public BGSModelMaterialSwap // 38 + { + public: + SF_RTTI_VTABLE(TESObjectANIO); + SF_FORMTYPE(ANIO); + + ~TESObjectANIO() override; // 00 + + // members + BGSEditorID formEditorID; // 60 + }; + static_assert(sizeof(TESObjectANIO) == 0x70); +} diff --git a/CommonLibSF/include/RE/T/TESObjectARMA.h b/CommonLibSF/include/RE/T/TESObjectARMA.h new file mode 100644 index 00000000..fe358b27 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectARMA.h @@ -0,0 +1,65 @@ +#pragma once + +#include "RE/A/AVMData.h" +#include "RE/B/BGSBipedObjectForm.h" +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSSnapTemplateComponent.h" +#include "RE/B/BSTArray.h" +#include "RE/S/Sexes.h" +#include "RE/T/TESObject.h" +#include "RE/T/TESRaceForm.h" + +namespace RE +{ + class BGSArtObject; + class BGSBodyPartData; + class BGSFootstepSet; + class BGSListForm; + class BGSMorphableObject; + class BGSTextureSet; + + struct OBJ_ARMA // DNAM + { + std::int8_t priorities[SEXES::kTotal]; // 0 + std::int8_t modelRange[SEXES::kTotal]; // 2 + std::int8_t unused[SEXES::kTotal]; // 4 + std::int8_t detectionSoundValue; // 6 + float weaponAdjust; // 8 + }; + static_assert(sizeof(OBJ_ARMA) == 0xC); + + class TESObjectARMA : + public TESObject, // 00 + public BGSSnapTemplateComponent, // 38 + public TESRaceForm, // 50 + public BGSBipedObjectForm // 60 + { + public: + SF_RTTI_VTABLE(TESObjectARMA); + SF_FORMTYPE(ARMA); + + ~TESObjectARMA() override; // 00 + + // members + BGSEditorID formEditorID; // 070 + OBJ_ARMA data; // 080 + BGSModelMaterialSwap bipedModel[SEXES::kTotal]; // 090 + BGSModelMaterialSwap bipedModelFacebones[SEXES::kTotal]; // 0E0 + BGSModelMaterialSwap unk130[SEXES::kTotal]; // 130 + TESModel unk180[SEXES::kTotal]; // 180 + BGSMorphableObject* unk1C0[SEXES::kTotal]; // 1C0 + BGSMorphableObject* unk1D0[SEXES::kTotal]; // 1D0 + BGSTextureSet* skinTextures[SEXES::kTotal]; // 1E0 + BGSListForm* skinTextureSwapLists[SEXES::kTotal]; // 1F0 + BSTArray unk200[SEXES::kTotal]; // 200 + std::uint64_t unk220; // 220 + std::uint64_t unk228; // 228 + BSTArray additionalRaces; // 230 + BGSBodyPartData* bodyPartData; // 240 + BGSFootstepSet* footstepSet; // 248 + BGSArtObject* artObject; // 250 + AVMData avmData; // 258 + }; + static_assert(sizeof(TESObjectARMA) == 0x280); +} diff --git a/CommonLibSF/include/RE/T/TESObjectBOOK.h b/CommonLibSF/include/RE/T/TESObjectBOOK.h new file mode 100644 index 00000000..66fca7b7 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectBOOK.h @@ -0,0 +1,78 @@ +#pragma once + +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSFeaturedItemMessage.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLocalizedString.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSPickupPutdownSounds.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESDescription.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESValueForm.h" +#include "RE/T/TESWeightForm.h" + +namespace RE +{ + class ActorValueInfo; + class BGSPerk; + class BGSScene; + class TESObjectSTAT; + class SpellItem; + + struct OBJ_BOOK + { + public: + enum class Flag + { + kNone = 0, + kAdvancesActorValue = 1 << 0, + kCantTake = 1 << 1, + kTeachesSpell = 1 << 2, + kHasBeenRead = 1 << 3, + kTeachesPerk = 1 << 4, + }; + + union Teaches + { + ActorValueInfo* actorValueToAdvance; + SpellItem* spell; + BGSPerk* perk; + }; + static_assert(sizeof(Teaches) == 0x8); + + // members + stl::enumeration flags; // 00 + Teaches teaches; // 08 + std::uint32_t textOffsetX; // 10 + std::uint32_t textOffsetY; // 14 + std::uint64_t unk18; // 18 + }; + static_assert(sizeof(OBJ_BOOK) == 0x20); + + class TESObjectBOOK : + public TESBoundObject, // 000 + public TESFullName, // 118 + public BGSModelMaterialSwap, // 128 + public TESValueForm, // 150 + public TESWeightForm, // 160 + public TESDescription, // 170 + public BGSDestructibleObjectForm, // 188 + public BGSPickupPutdownSounds, // 198 + public BGSKeywordForm, // 200 + public BGSFeaturedItemMessage // 230 + { + public: + SF_RTTI_VTABLE(TESObjectBOOK); + SF_FORMTYPE(BOOK); + + // members + OBJ_BOOK data; // 240 + TESObjectSTAT* inventoryModel; // 260 + TESDescription itemCardDescription; // 268 + BGSScene* scene; // 280 + BGSLocalizedString unk288; // 288 + BGSLocalizedString unk290; // 290 + }; + static_assert(sizeof(TESObjectBOOK) == 0x298); +} diff --git a/CommonLibSF/include/RE/T/TESObjectCONT.h b/CommonLibSF/include/RE/T/TESObjectCONT.h new file mode 100644 index 00000000..0fc3c068 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectCONT.h @@ -0,0 +1,64 @@ +#pragma once + +#include "RE/B/BGSAttachParentArray.h" +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSForcedLocRefType.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSNativeTerminalForm.h" +#include "RE/B/BGSOpenCloseForm.h" +#include "RE/B/BGSPropertySheet.h" +#include "RE/T/TESBoundAnimObject.h" +#include "RE/T/TESContainer.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESMagicTargetForm.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSListForm; + + struct CONT_DATA + { + enum class Flag + { + kNone = 0, + kAllowsSoundsWhenAnimation = 1 << 0, + kRespawn = 1 << 1, + kShowOwner = 1 << 2 + }; + + stl::enumeration contFlags; // 0 + }; + static_assert(sizeof(CONT_DATA) == 0x1); + + class TESObjectCONT : + public TESBoundAnimObject, // 000 + public TESContainer, // 118 + public TESFullName, // 130 + public BGSModelMaterialSwap, // 140 + public TESMagicTargetForm, // 168 + public BGSDestructibleObjectForm, // 170 + public BGSOpenCloseForm, // 180 + public BGSKeywordForm, // 188 + public BGSForcedLocRefType, // 1B8 + public BGSPropertySheet, // 1D0 + public BGSNativeTerminalForm // 1E0 + { + public: + SF_RTTI_VTABLE(TESObjectCONT); + SF_FORMTYPE(CONT); + + ~TESObjectCONT() override; // 00 + + // members + CONT_DATA data; // 1F0 + BGSAudio::WwiseSoundHook openSound; // 1F8 + BGSAudio::WwiseSoundHook closeSound; // 228 + BGSAudio::WwiseSoundHook takeAllSound; // 258 + BGSListForm* containsOnlyList; // 288 + BGSAttachParentArray attachParents; // 290 + std::uint8_t unk2B0; // 2B0 + }; + static_assert(sizeof(TESObjectCONT) == 0x2B8); +} diff --git a/CommonLibSF/include/RE/T/TESObjectDOOR.h b/CommonLibSF/include/RE/T/TESObjectDOOR.h new file mode 100644 index 00000000..de872a37 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectDOOR.h @@ -0,0 +1,61 @@ +#pragma once + +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSForcedLocRefType.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLocalizedString.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSNativeTerminalForm.h" +#include "RE/B/BGSNavmeshableObject.h" +#include "RE/B/BGSOpenCloseForm.h" +#include "RE/B/BGSPropertySheet.h" +#include "RE/T/TESBoundAnimObject.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESMagicTargetForm.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class TESObjectDOOR : + public TESBoundAnimObject, // 000 + public TESFullName, // 118 + public BGSModelMaterialSwap, // 128 + public TESMagicTargetForm, // 150 + public BGSDestructibleObjectForm, // 158 + public BGSOpenCloseForm, // 168 + public BGSKeywordForm, // 170 + public BGSNativeTerminalForm, // 1A0 + public BGSForcedLocRefType, // 1B0 + public BGSPropertySheet, // 1C8 + public BGSNavmeshableObject // 1D8 + { + public: + SF_RTTI_VTABLE(TESObjectDOOR); + SF_FORMTYPE(DOOR); + + enum class Flag + { + kNone = 0, + kAutomatic = 1 << 1, + kHidden = 1 << 2, + kMinimalUse = 1 << 3, + kSliding = 1 << 4, + kDoNotOpenInCombatSearch = 1 << 5, + kNoToText = 1 << 6 + }; + + ~TESObjectDOOR() override; // 00 + + // members + BGSLocalizedString altOpenText; // 1E0 + BGSLocalizedString altCloseText; // 1E8 + BGSAudio::WwiseSoundHook openSound; // 1F0 + BGSAudio::WwiseSoundHook closeSound; // 220 + BGSAudio::WwiseSoundHook lockSound; // 250 + std::uint32_t unk280; // 280 + std::uint32_t unk284; // 284 + stl::enumeration flags; // 288 + BSTArray randomTeleports; // 290 + }; + static_assert(sizeof(TESObjectDOOR) == 0x2A0); +} diff --git a/CommonLibSF/include/RE/T/TESObjectLIGH.h b/CommonLibSF/include/RE/T/TESObjectLIGH.h new file mode 100644 index 00000000..9dccf411 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectLIGH.h @@ -0,0 +1,31 @@ +#pragma once + +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSEquipType.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSOpenCloseForm.h" +#include "RE/B/BGSPropertySheet.h" +#include "RE/T/TESBoundAnimObject.h" +#include "RE/T/TESValueForm.h" +#include "RE/T/TESWeightForm.h" + +namespace RE +{ + class TESObjectLIGH : + public TESBoundAnimObject, // 000 + public BGSModelMaterialSwap, // 118 + public TESWeightForm, // 140 + public TESValueForm, // 150 + public BGSDestructibleObjectForm, // 160 + public BGSEquipType, // 170 + public BGSPropertySheet, // 180 + public BGSOpenCloseForm, // 190 + public BGSKeywordForm // 198 + { + public: + SF_RTTI_VTABLE(TESObjectLIGH); + SF_FORMTYPE(LIGH); + }; + //static_assert(sizeof(TESObjectLIGH) == 0x300); +} diff --git a/CommonLibSF/include/RE/T/TESObjectMISC.h b/CommonLibSF/include/RE/T/TESObjectMISC.h index 0fb4e263..1d4b98e5 100644 --- a/CommonLibSF/include/RE/T/TESObjectMISC.h +++ b/CommonLibSF/include/RE/T/TESObjectMISC.h @@ -33,6 +33,9 @@ namespace RE ~TESObjectMISC() override; // 00 + // add + virtual void Unk_82(); // 82 - { return; } + // members BGSLocalizedString shortName; // 280 std::uint32_t flags; // 288 diff --git a/CommonLibSF/include/RE/T/TESObjectSTAT.h b/CommonLibSF/include/RE/T/TESObjectSTAT.h new file mode 100644 index 00000000..01406aa2 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectSTAT.h @@ -0,0 +1,39 @@ +#pragma once + +#include "RE/B/BGSForcedLocRefType.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSNavmeshableObject.h" +#include "RE/B/BGSPropertySheet.h" +#include "RE/T/TESBoundObject.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + struct TESObjectSTATData + { + public: + // members + float unk00; // 00 + float unk04; // 04 + }; + static_assert(sizeof(TESObjectSTATData) == 0x8); + + class TESObjectSTAT : + public TESBoundObject, // 000 + public BGSModelMaterialSwap, // 118 + public BGSPropertySheet, // 140 + public BGSForcedLocRefType, // 150 + public BGSNavmeshableObject // 168 + { + public: + SF_RTTI_VTABLE(TESObjectSTAT); + SF_FORMTYPE(STAT); + + ~TESObjectSTAT() override; // 00 + + // members + TESObjectSTATData data; // 170 + BGSAudio::WwiseSoundHook ambientSound; // 178 + }; + static_assert(sizeof(TESObjectSTAT) == 0x1A8); +} diff --git a/CommonLibSF/include/RE/T/TESObjectWEAP.h b/CommonLibSF/include/RE/T/TESObjectWEAP.h new file mode 100644 index 00000000..c5909f92 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESObjectWEAP.h @@ -0,0 +1,56 @@ +#pragma once + +#include "RE/B/BGSAttachParentArray.h" +#include "RE/B/BGSBlockBashData.h" +#include "RE/B/BGSDestructibleObjectForm.h" +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSEquipType.h" +#include "RE/B/BGSInstanceNamingRulesForm.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BGSPickupPutdownSounds.h" +#include "RE/B/BGSPreloadable.h" +#include "RE/B/BSTSmartPointer.h" +#include "RE/T/TESBoundObject.h" +#include "RE/T/TESDescription.h" +#include "RE/T/TESEnchantableForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class TESObjectWEAPInstanceData; + + namespace BGSMod::Attachment + { + class Mod; + } + + class TESObjectWEAP : + public TESBoundObject, // 000 + public TESFullName, // 118 + public BGSModelMaterialSwap, // 128 + public TESEnchantableForm, // 150 + public BGSDestructibleObjectForm, // 168 + public BGSEquipType, // 178 + public BGSPreloadable, // 188 + public BGSPickupPutdownSounds, // 190 + public BGSBlockBashData, // 1F8 + public BGSKeywordForm, // 210 + public TESDescription, // 240 + public BGSInstanceNamingRulesForm // 258 + { + public: + SF_RTTI_VTABLE(TESObjectWEAP); + SF_FORMTYPE(WEAP); + + ~TESObjectWEAP() override; // 00 + + // members + BGSEditorID formEditorID; // 268 + BSTSmartPointer weaponData; // 278 + BGSAttachParentArray attachParents; // 280 + BGSMod::Attachment::Mod* embeddedWeaponMod; // 2A0 + std::uint8_t unk2A8; // 2A8 + }; + static_assert(sizeof(TESObjectWEAP) == 0x2B0); +} diff --git a/CommonLibSF/vcpkg.json b/CommonLibSF/vcpkg.json index 9411d0ab..c68bb292 100644 --- a/CommonLibSF/vcpkg.json +++ b/CommonLibSF/vcpkg.json @@ -1,7 +1,7 @@ { "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json", "name": "commonlibsf", - "version-date": "2023-11-21", + "version-date": "2023-11-21.2", "port-version": 0, "description": "A collaborative reverse-engineered library for Starfield.", "homepage": "https://github.com/Starfield-Reverse-Engineering/CommonLibSF", diff --git a/README.md b/README.md index 87c5570a..b8554c4d 100644 --- a/README.md +++ b/README.md @@ -5,7 +5,7 @@ [![C++23](https://img.shields.io/static/v1?label=standard&message=c%2B%2B23&color=blue&logo=c%2B%2B&&logoColor=red&style=flat)](https://en.cppreference.com/w/cpp/compiler_support) ![Platform](https://img.shields.io/static/v1?label=platform&message=windows&color=dimgray&style=flat&logo=windows) [![Game version](https://img.shields.io/badge/game%20version-1.7.36-orange)](#Developing-with-CommonLibSF) -[![VCPKG_VER](https://img.shields.io/static/v1?label=vcpkg%20registry&message=2023-11-21&color=green&style=flat)](https://github.com/Starfield-Reverse-Engineering/Starfield-RE-vcpkg) +[![VCPKG_VER](https://img.shields.io/static/v1?label=vcpkg%20registry&message=2023-11-21.2&color=green&style=flat)](https://github.com/Starfield-Reverse-Engineering/Starfield-RE-vcpkg) [![Main CI](https://img.shields.io/github/actions/workflow/status/Starfield-Reverse-Engineering/CommonLibSF/main_ci.yml)](https://github.com/Starfield-Reverse-Engineering/CommonLibSF/actions/workflows/main_ci.yml) ## Build Dependencies