diff --git a/CommonLibSF/include/RE/B/BGSAction.h b/CommonLibSF/include/RE/B/BGSAction.h new file mode 100644 index 00000000..165da9c0 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAction.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BGSKeyword.h" + +namespace RE +{ + class BGSAction : public BGSKeyword + { + public: + SF_RTTI_VTABLE(BGSAction); + SF_FORMTYPE(AACT); + + ~BGSAction() override; // 00 + + // members + std::uint32_t index; // 80 + }; + static_assert(sizeof(BGSAction) == 0x80); +} diff --git a/CommonLibSF/include/RE/B/BGSAddonNode.h b/CommonLibSF/include/RE/B/BGSAddonNode.h new file mode 100644 index 00000000..65850f33 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAddonNode.h @@ -0,0 +1,38 @@ +#pragma once + +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/T/TESBoundObject.h" +#include "RE/W/WWiseSoundHook.h" + +namespace RE +{ + class TESObjectLIGH; + + struct ADDON_DATA + { + public: + // members + std::uint16_t masterParticleCap; // 0 + std::int8_t flags; // 2 + }; + static_assert(sizeof(ADDON_DATA) == 0x4); + + class BGSAddonNode : + public TESBoundObject, // 00 + public BGSModelMaterialSwap // E0 + { + public: + SF_RTTI_VTABLE(BGSAddonNode); + SF_FORMTYPE(ADDN); + + ~BGSAddonNode() override; // 00 + + // members + std::uint32_t index; // 108 + BGSAudio::WwiseSoundHook sound; // 110 + TESObjectLIGH* light; // 140 + std::uint8_t unk148[776]; // 148 - reflection data + ADDON_DATA data; // 450 + }; + static_assert(sizeof(BGSAddonNode) == 0x458); +} diff --git a/CommonLibSF/include/RE/B/BGSAffinityEvent.h b/CommonLibSF/include/RE/B/BGSAffinityEvent.h new file mode 100644 index 00000000..26370fbb --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAffinityEvent.h @@ -0,0 +1,42 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class ActorValueInfo; + class TESFaction; + class TESGlobal; + class TESNPC; + + class BGSAffinityEvent : public TESForm + { + public: + SF_RTTI_VTABLE(BGSAffinityEvent); + SF_FORMTYPE(AFFE); + + struct ReactionData + { + public: + // members + TESNPC* npc; // 00 + TESGlobal* reaction; // 08 + }; + static_assert(sizeof(ReactionData) == 0x10); + + ~BGSAffinityEvent() override; // 00 + + // members + ActorValueInfo* actorValue; // 30 + TESGlobal* eventSize; // 38 + TESGlobal* eventDistance; // 40 + TESGlobal* eventCooldown; // 48 + TESFaction* faction; // 50 + std::uint32_t flags; // 58 + std::uint32_t unk5C; // 5C + std::vector reactionData; // 60 + std::uint32_t unk78; // 78 + }; + static_assert(sizeof(BGSAffinityEvent) == 0x80); +} diff --git a/CommonLibSF/include/RE/B/BGSAmbienceSet.h b/CommonLibSF/include/RE/B/BGSAmbienceSet.h new file mode 100644 index 00000000..100c043f --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAmbienceSet.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSAmbienceSet : public TESForm + { + public: + SF_RTTI_VTABLE(BGSAmbienceSet); + SF_FORMTYPE(AMBS); + + ~BGSAmbienceSet() override; // 00 + + // members + std::uint64_t unk30; // 30 + std::uint64_t unk38; // 38 + std::uint64_t unk40; // 40 + bool unk48; // 48 + BGSAudio::WwiseSoundHook unk50; // 50 + }; + static_assert(sizeof(BGSAmbienceSet) == 0x80); +} diff --git a/CommonLibSF/include/RE/B/BGSArtObject.h b/CommonLibSF/include/RE/B/BGSArtObject.h index 4fab0f8e..0c1a060d 100644 --- a/CommonLibSF/include/RE/B/BGSArtObject.h +++ b/CommonLibSF/include/RE/B/BGSArtObject.h @@ -6,7 +6,7 @@ namespace RE { - class EffectShader; + class TESEffectShader; class BGSArtObject : public TESBoundObject, // 000 @@ -36,8 +36,8 @@ namespace RE ~BGSArtObject() override; // 00 // members - Data data; // 138 - EffectShader* effectShader; // 140 + Data data; // 138 + TESEffectShader* effectShader; // 140 }; static_assert(sizeof(BGSArtObject) == 0x148); } diff --git a/CommonLibSF/include/RE/B/BGSAtmosphere.h b/CommonLibSF/include/RE/B/BGSAtmosphere.h new file mode 100644 index 00000000..e984bd15 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAtmosphere.h @@ -0,0 +1,140 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSTArray.h" + +namespace RE +{ + class BGSResource; + class TESClimate; + class TESImageSpace; + + namespace BSGalaxy + { + class BGSSunPresetForm; + } + + class BGSAtmosphere : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSAtmosphere); + SF_FORMTYPE(ATMO); + + enum class ATMOSPHERE_TYPE + { + kNone = 0, + kNitrogen, + kMethane, + kCarbonDioxide, + kOxygen, + kLowOxygen, + kHighOxygen + }; + + struct alignas(4) ScatteringSettings + { + public: + struct alignas(4) RayleighSettings + { + float moleculesPerUnitVolume; // 00 + float refractiveIndexOfAir; // 04 + float depolarizationFactor; // 08 + bool useOzoneAbsorptionApproximation; // 0C + DirectX::XMFLOAT4 ozoneAbsorptionCoef; // 10 + DirectX::XMFLOAT4 rayleighCoef; // 20 + }; + static_assert(sizeof(RayleighSettings) == 0x30); + + struct alignas(4) MieSettings + { + float aerosolDensity; // 00 + float aerosolAbsorbtion; // 04 + DirectX::XMFLOAT4 mieCoef; // 08 + }; + static_assert(sizeof(MieSettings) == 0x18); + + // members + std::uint32_t height; // 00 + bool useCustomCoefficients; // 04 + RayleighSettings rayleigh; // 08 + MieSettings mie; // 38 + float aerosolPhaseFunction; // 50 + float scatteringScale; // 54 + float edgeEffectExponent; // 58 + float edgeEffectCoefficient; // 5C + }; + static_assert(sizeof(ScatteringSettings) == 0x60); + + struct alignas(4) StarSettings + { + float planetStarfieldBackgroundScale; // 00 + float planetStarfieldBackgroundGIContribution; // 04 + float planetStarfieldStarBrightnessScale; // 08 + float planetStarGlowBackgroundScale; // 0C + float horizonScatteringBlendScale; // 10 + bool disableSimulatedVisibility; // 14 + float staticVisibility; // 18 + }; + static_assert(sizeof(StarSettings) == 0x1C); + + struct alignas(4) CelestialBodySettings + { + float celestialBodyIlluminanceScale; // 0 + }; + static_assert(sizeof(CelestialBodySettings) == 0x4); + + struct OverrideSettings + { + BSGalaxy::BGSSunPresetForm* sunPresetOverride; // 00 + }; + static_assert(sizeof(OverrideSettings) == 0x8); + + struct MiscSettings + { + stl::enumeration atmosphereType; // 00 + BSTArray inorganicResources; // 08 + TESImageSpace* imageSpaceDay; // 18 + TESImageSpace* imageSpaceNight; // 20 + TESClimate* climateOverride; // 28 + }; + static_assert(sizeof(MiscSettings) == 0x30); + + struct AtmosphereSettings + { + public: + // members + BGSAtmosphere* parent; // 00 + ScatteringSettings scattering; // 08 + StarSettings stars; // 68 + CelestialBodySettings celestialBodies; // 84 + OverrideSettings overrides; // 88 + MiscSettings misc; // 90 + }; + static_assert(sizeof(AtmosphereSettings) == 0xC0); + + ~BGSAtmosphere() override; // 00 + + // members + AtmosphereSettings settings; // 030 + BSTArray unk0F0; // 0F0 - incomplete reflection? + std::uint64_t unk100; // 100 + std::uint32_t unk108; // 108 + std::uint32_t unk10C; // 10C + std::uint32_t unk110; // 110 + std::uint32_t unk114; // 114 + std::uint32_t unk118; // 118 + std::uint32_t unk11C; // 11C + std::uint32_t unk120; // 120 + std::uint32_t unk124; // 124 + std::uint32_t unk128; // 128 + std::uint32_t unk12C; // 12C + std::uint32_t unk130; // 130 + std::uint32_t unk134; // 134 + std::uint32_t unk138; // 138 + std::uint32_t unk13C; // 13C + std::uint32_t unk140; // 140 + std::uint32_t unk144; // 144 + std::uint32_t unk148; // 148 + }; + static_assert(sizeof(BGSAtmosphere) == 0x150); +} diff --git a/CommonLibSF/include/RE/B/BGSAttractionRule.h b/CommonLibSF/include/RE/B/BGSAttractionRule.h new file mode 100644 index 00000000..7a664e15 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSAttractionRule.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSAttractionRule : public TESForm + { + public: + SF_RTTI_VTABLE(BGSAttractionRule); + SF_FORMTYPE(AORU); + + class Rule + { + public: + // members + float radius; // 00 + float minDelay; // 04 + float maxDelay; // 08 + bool requiresLOS; // 0C + bool combatTarget; // 0D + }; + static_assert(sizeof(Rule) == 0x10); + + ~BGSAttractionRule() override; // 00 + + // members + BGSEditorID formEditorID; // 30 + Rule attractionRule; // 40 + }; + static_assert(sizeof(BGSAttractionRule) == 0x50); +} diff --git a/CommonLibSF/include/RE/B/BGSBiome.h b/CommonLibSF/include/RE/B/BGSBiome.h new file mode 100644 index 00000000..998939d8 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSBiome.h @@ -0,0 +1,125 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESTexture.h" + +namespace RE +{ + class BGSAmbienceSet; + class BGSGroundCover; + class BGSLayeredMaterialSwap; + class BGSMusicType; + class BGSResourceGenerationData; + class BGSTimeOfDayData; + class TESClimate; + class TESGlobal; + class TESLandTexture; + class TESWaterForm; + + namespace BGSSurface + { + class PatternStyle; + } + + class BGSBiome : + public TESForm, // 00 + public TESFullName, // 30 + public BGSKeywordForm // 40 + { + public: + SF_RTTI_VTABLE(BGSBiome); + SF_FORMTYPE(BIOM); + + struct LandData + { + TESLandTexture* landTexture; // 00 + BGSGroundCover* groundCover; // 08 + }; + static_assert(sizeof(LandData) == 0x10); + + struct BTPSData + { + float unk00; // 00 + float unk04; // 04 + float unk08; // 08 + float unk0C; // 0C + float unk10; // 10 + float unk14; // 14 + float unk18; // 18 + float unk1C; // 1C + TESTexture texture; // 20 + }; + static_assert(sizeof(BTPSData) == 0x30); + + ~BGSBiome() override; // 00 + + // members + BGSEditorID formEditorID; // 070 + LandData unk80[7]; // 080 - LNAM + LandData unkF0[7]; // 0F0 - ANAM + BTPSData unk160[7]; // 160 - BTPS + std::uint64_t unk2B0; // 2B0 + float unk2B8; // 2B8 + float unk2BC; // 2BC + std::uint32_t unk2C0; // 2C0 + float unk2C4; // 2C4 + std::uint32_t unk2C8; // 2C8 + float unk2CC; // 2CC + TESTexture groundLayerNormal; // 2D0 + std::uint64_t unk2E0; // 2E0 + std::uint32_t unk2E8; // 2E8 + std::uint32_t unk2EC; // 2EC + BSTArray unk2F0; // 2F0 + BSTArray resourceGenerationData; // 300 + BSTArray unk310; // 310 + BSTArray materialSwaps; // 320 + std::uint64_t unk330; // 330 + std::uint64_t unk338; // 338 + std::uint64_t unk340; // 340 + std::uint64_t unk348; // 348 + std::uint64_t unk350; // 350 + std::uint64_t unk358; // 358 + std::uint64_t unk360; // 360 + std::uint64_t unk368; // 368 + std::uint64_t unk370; // 370 + std::uint64_t unk378; // 378 + std::uint64_t unk380; // 380 + std::uint64_t unk388; // 388 + TESClimate* climate; // 290 + TESWaterForm* water; // 398 + std::uint32_t unk3A0; // 3A0 + std::uint32_t unk3A4; // 3A4 + BGSBiome* unk3A8; // 3A8 + BGSAmbienceSet* ambienceSet; // 3B0 + BGSMusicType* musicType; // 3B8 + BGSTimeOfDayData* timeOfDayData; // 3C0 + TESGlobal* unk3C8; // 3C8 + TESGlobal* unk3D0; // 3D0 + TESGlobal* unk3D8; // 3D8 + std::uint32_t color; // 3E0 + std::uint32_t biomeColor3; // 3E4 + std::uint32_t biomeColor1; // 3E8 + std::uint32_t biomeColor2; // 3EC + std::uint8_t unk3F0; // 3F0 + float unk3F4; // 3F4 + float unk3F8; // 3F8 + float unk3FC; // 3FC + std::uint64_t unk400; // 400 + std::uint64_t unk408; // 408 + std::uint64_t unk410; // 410 + std::uint64_t unk418; // 418 + std::uint64_t unk420; // 420 + std::uint64_t unk428; // 428 + std::uint64_t unk430; // 430 + BSFixedString unk438; // 438 + std::uint8_t unk440; // 440 + BGSSurface::PatternStyle* patternStyle; // 448 + std::uint32_t unk450; // 450 + std::uint8_t unk454; // 454 + }; + static_assert(sizeof(BGSBiome) == 0x458); +} diff --git a/CommonLibSF/include/RE/B/BGSBodyPartData.h b/CommonLibSF/include/RE/B/BGSBodyPartData.h new file mode 100644 index 00000000..0f7c5271 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSBodyPartData.h @@ -0,0 +1,62 @@ +#pragma once + +#include "RE/A/ActorValues.h" +#include "RE/B/BGSBodyPartDefs.h" +#include "RE/B/BGSPreloadable.h" +#include "RE/B/BSFixedString.h" +#include "RE/N/NiPoint3.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESModel.h" + +namespace RE +{ + class ActorValueInfo; + class BGSArtObject; + class BGSDebris; + class BGSExplosion; + class BGSImpactDataSet; + class BGSMaterialType; + + class BGSBodyPart + { + public: + // members + float unk00; // 00 + float unk04; // 04 + std::uint8_t flags; // 08 + stl::enumeration limbEnum; // 09 + std::uint8_t unk0A; // 0A + std::uint16_t unk0C; // 0C + BGSDebris* onCrippleDebris; // 10 + BGSExplosion* onCrippleExplosion; // 18 + BGSImpactDataSet* onCrippleImpactDataSet; // 20 + ActorValueInfo* actorValue; // 28 + BGSArtObject* onCrippleArt; // 30 + BGSMaterialType* goreEffectsMaterial; // 38 + BGSMaterialType* onCrippleMaterial; // 40 + BGSBodyPartDefs::HitReactionData hitReactionData; // 48 + BSFixedString unk70; // 70 + BSFixedString unk78; // 78 + BSFixedString unk80; // 80 + BSFixedStringCS unk88; // 88 + BSFixedString unk90; // 90 + }; + static_assert(sizeof(BGSBodyPart) == 0x98); + + class BGSBodyPartData : + public TESForm, // 00 + public TESModel, // 30 + public BGSPreloadable // 50 + { + public: + SF_RTTI_VTABLE(BGSBodyPartData); + SF_FORMTYPE(BPTD); + + ~BGSBodyPartData() override; // 00 + + // members + BGSBodyPart* parts[BGSBodyPartDefs::LIMB_ENUM::kTotal]; // 058 + BGSBodyPartDefs::HitReactionData defaultHitReactionData; // 128 + }; + static_assert(sizeof(BGSBodyPartData) == 0x150); +} diff --git a/CommonLibSF/include/RE/B/BGSBoneModifier.h b/CommonLibSF/include/RE/B/BGSBoneModifier.h new file mode 100644 index 00000000..07c55214 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSBoneModifier.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSBoneModifier : public TESForm + { + public: + SF_RTTI_VTABLE(BGSBoneModifier); + SF_FORMTYPE(BMOD); + + ~BGSBoneModifier() override; // 00 + + // members + void* unk30; // 30 + }; + static_assert(sizeof(BGSBoneModifier) == 0x38); +} diff --git a/CommonLibSF/include/RE/B/BGSCameraPath.h b/CommonLibSF/include/RE/B/BGSCameraPath.h new file mode 100644 index 00000000..02b9ba54 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSCameraPath.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSCameraPath : public TESForm + { + public: + SF_RTTI_VTABLE(BGSCameraPath); + SF_FORMTYPE(CPTH); + + ~BGSCameraPath() override; // 00 + + // members + TESCondition conditions; // 30 + std::uint8_t unk40; // 40 + BSTArray unk48; // 48 + BSTArray unk58; // 58 + BGSCameraPath* parentPath; // 68 + BGSCameraPath* prevPath; // 70 + }; + static_assert(sizeof(BGSCameraPath) == 0x78); +} diff --git a/CommonLibSF/include/RE/B/BGSCameraShot.h b/CommonLibSF/include/RE/B/BGSCameraShot.h new file mode 100644 index 00000000..cdaab3ef --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSCameraShot.h @@ -0,0 +1,81 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESImageSpaceModifiableForm.h" +#include "RE/T/TESModel.h" + +namespace RE +{ + class BGSCameraShot : + public TESForm, // 00 + public TESModel, // 30 + public BGSKeywordForm, // 50 + public TESImageSpaceModifiableForm // 80 + { + public: + SF_RTTI_VTABLE(BGSCameraShot); + SF_FORMTYPE(CAMS); + + enum class CAM_ACTION + { + kShoot = 0, + kFly = 1, + kHit = 2, + kZoom = 3 + }; + + enum class CAM_OBJECT + { + kAttacker = 0, + kProjectile = 1, + kTarget = 2, + kLeadActor = 3 + }; + + struct CAMERA_SHOT_DATA // DATA + { + public: + enum class Flag + { + kNone = 0, + kPositionFollowsLocation = 1 << 0, + kRotationFollowsTarget = 1 << 1, + kDontFollowBone = 1 << 2, + kFirstPersonCamera = 1 << 3, + kNoTracer = 1 << 4, + kStartAtTimeZero = 1 << 5, + kDontResetLocationSpring = 1 << 6, + kDontResetTargetSpring = 1 << 7 + }; + + // members + stl::enumeration cameraAction; // 00 + stl::enumeration location; // 04 + stl::enumeration target; // 08 + std::uint32_t flags; // 0C + float playerTimeMult; // 10 + float targetTimeMult; // 14 + float globalTimeMult; // 18 + float maxTime; // 1C + float minTime; // 20 + float targetPercentBetweenActors; // 24 + float nearTargetDistance; // 28 + float locationSpring; // 2C + float targetSpring; // 30 + float rotationOffsetX; // 34 + float rotationOffsetY; // 38 + float rotationOffsetZ; // 3C + }; + static_assert(sizeof(CAMERA_SHOT_DATA) == 0x40); + + ~BGSCameraShot() override; // 00 + + // members + CAMERA_SHOT_DATA data; // 90 + TESCondition conditions; // D0 + BSFixedString animPath; // E0 + }; + static_assert(sizeof(BGSCameraShot) == 0xE8); +} diff --git a/CommonLibSF/include/RE/B/BGSChallengeForm.h b/CommonLibSF/include/RE/B/BGSChallengeForm.h new file mode 100644 index 00000000..f9abf798 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSChallengeForm.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + class BGSChallengeForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSChallengeForm); + SF_FORMTYPE(CHAL); + + ~BGSChallengeForm() override; // 00 + }; + static_assert(sizeof(BGSChallengeForm) == 0x30); +} diff --git a/CommonLibSF/include/RE/B/BGSCloudForm.h b/CommonLibSF/include/RE/B/BGSCloudForm.h new file mode 100644 index 00000000..9ab1765d --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSCloudForm.h @@ -0,0 +1,96 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + class BGSEffectSequenceForm; + + class BGSCloudForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSCloudForm); + SF_FORMTYPE(CLDF); + + struct ShadowParams + { + public: + // members + bool enabled; // 00 + BSFixedString opacityTexture; // 08 + float tilingPerKm; // 10 + float elevationKm; // 14 + float strength; // 18 + float windScale; // 1C + }; + static_assert(sizeof(ShadowParams) == 0x20); + + struct CloudLayer + { + public: + // members + BSFixedString name; // 00 + BSFixedString colorTexture; // 08 + BSFixedString thicknessTexture; // 10 + BSFixedString normalTexture; // 18 + BSFixedString opacityTexture; // 20 + float elevationKm; // 28 + float heightKm; // 2C + float distanceKm; // 30 + float thickness; // 34 + float textureShadowOffset; // 38 + float textureShadowStrength; // 3C + float normalShadowStrength; // 40 + std::uint32_t tiling; // 44 + std::uint32_t verticalTiling; // 48 + float topBlendDistanceKm; // 4C + float topBlendStartKm; // 50 + float bottomBlendDistanceKm; // 54 + float bottomBlendStartKm; // 58 + float windScale; // 5C + float density; // 60 + float coverage; // 64 + float alphaAdd; // 68 + float alphaMultiply; // 6C + DirectX::XMCOLOR tint; // 70 + bool enableEditorRendering; // 74 + }; + static_assert(sizeof(CloudLayer) == 0x78); + + struct CloudPlane + { + public: + // members + BSFixedString name; // 00 + BSFixedString colorTexture; // 08 + BSFixedString thicknessTexture; // 10 + BSFixedString normalTexture; // 18 + BSFixedString opacityTexture; // 20 + float elevationKm; // 28 + float fadeStartKm; // 2C + float fadeDistanceKm; // 30 + float thickness; // 34 + float textureShadowOffset; // 38 + float textureShadowStrength; // 3C + float normalShadowStrength; // 40 + float tilingPerKm; // 44 + float windScale; // 48 + float density; // 4C + float coverage; // 50 + float alphaAdd; // 54 + float alphaMultiply; // 58 + DirectX::XMCOLOR tint; // 5C + bool enableEditorRendering; // 60 + }; + static_assert(sizeof(CloudPlane) == 0x68); + + ~BGSCloudForm() override; // 00 + + // members + ShadowParams shadows; // 030 + std::array layers; // 050 + std::array planes; // 230 + BGSEffectSequenceForm* cloudCardSequence; // 3D0 + }; + static_assert(sizeof(BGSCloudForm) == 0x3D8); +} diff --git a/CommonLibSF/include/RE/B/BGSCollisionLayer.h b/CommonLibSF/include/RE/B/BGSCollisionLayer.h new file mode 100644 index 00000000..d8533460 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSCollisionLayer.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/C/Color.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSCollisionLayer : public TESForm + { + public: + SF_RTTI_VTABLE(BGSCollisionLayer); + SF_FORMTYPE(COLL); + + enum class FLAG // GNAM + { + kNone = 0, + kTriggerVolume = 1 << 0, + kSensor = 1 << 1, + kNavmeshObstacle = 1 << 2 + }; + + ~BGSCollisionLayer() override; // 00 + + // members + std::uint32_t collisionIdx; // 30 + std::uint32_t debugColor; // 34 + stl::enumeration flags; // 38 + BSFixedString name; // 40 + BSTArray collidesWith; // 48 + }; + static_assert(sizeof(BGSCollisionLayer) == 0x58); +} diff --git a/CommonLibSF/include/RE/B/BGSColorForm.h b/CommonLibSF/include/RE/B/BGSColorForm.h new file mode 100644 index 00000000..fbac2297 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSColorForm.h @@ -0,0 +1,37 @@ +#pragma once + +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class BGSColorForm : + public TESForm, // 00 + public TESFullName // 30 + { + public: + SF_RTTI_VTABLE(BGSColorForm); + SF_FORMTYPE(CLFM); + + enum class Flag // FNAM + { + kNone = 0, + kPlayable = 1 << 0, + kRemappingIndex = 1 << 1, + kExtendedLUT = 1 << 2 + }; + + ~BGSColorForm() override; // 00 + + // memebrs + union + { + std::uint32_t color; + float remappingIndex; + }; // 40 + TESCondition conditions; // 48 + stl::enumeration flags; // 58 + }; + static_assert(sizeof(BGSColorForm) == 0x60); +} diff --git a/CommonLibSF/include/RE/B/BGSConditionForm.h b/CommonLibSF/include/RE/B/BGSConditionForm.h new file mode 100644 index 00000000..8419ce7b --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSConditionForm.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESQuest; + class TESPackage; + + class BGSConditionForm : public TESForm + { + public: + SF_RTTI_VTABLE(BGSConditionForm); + SF_FORMTYPE(CNDF); + + ~BGSConditionForm() override; // 00 + + // members + TESCondition conditions; // 30 + TESQuest* quest; // 40 + TESPackage* package; // 48 + std::uint32_t unk50; // 50 + std::uint8_t unk54; // 54 + }; + static_assert(sizeof(BGSConditionForm) == 0x58); +} diff --git a/CommonLibSF/include/RE/B/BGSCurve3DForm.h b/CommonLibSF/include/RE/B/BGSCurve3DForm.h new file mode 100644 index 00000000..a65072d6 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSCurve3DForm.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSFloat3DCurve.h" + +namespace RE +{ + class BGSCurve3DForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSCurve3DForm); + SF_FORMTYPE(CUR3); + + ~BGSCurve3DForm() override; // 00 + + // members + BSFloat3DCurve curve; // 30 + }; + static_assert(sizeof(BGSCurve3DForm) == 0xF0); +} diff --git a/CommonLibSF/include/RE/B/BGSCurveForm.h b/CommonLibSF/include/RE/B/BGSCurveForm.h new file mode 100644 index 00000000..daf6eedf --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSCurveForm.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSFloatCurve.h" + +namespace RE +{ + class BGSCurveForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSCurveForm); + SF_FORMTYPE(CURV); + + ~BGSCurveForm() override; // 00 + + // members + BSFloatCurve curve; // 30 + }; + static_assert(sizeof(BGSCurveForm) == 0x70); +} diff --git a/CommonLibSF/include/RE/B/BGSDamageType.h b/CommonLibSF/include/RE/B/BGSDamageType.h new file mode 100644 index 00000000..e9649b2a --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSDamageType.h @@ -0,0 +1,34 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class ActorValueInfo; + class MagicItem; + + class BGSDamageType : + public TESForm, // 00 + public TESFullName // 30 + { + public: + SF_RTTI_VTABLE(BGSDamageType); + SF_FORMTYPE(DMGT); + + ~BGSDamageType() override; // 00 + + struct Data + { + public: + // members + ActorValueInfo* resistance; // 00 + MagicItem* spell; // 08 + }; + static_assert(sizeof(Data) == 0x10); + + // members + Data data; // 40 + }; + static_assert(sizeof(BGSDamageType) == 0x50); +} diff --git a/CommonLibSF/include/RE/B/BGSDebris.h b/CommonLibSF/include/RE/B/BGSDebris.h new file mode 100644 index 00000000..08d194a9 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSDebris.h @@ -0,0 +1,35 @@ +#pragma once + +#include "RE/B/BGSPreloadable.h" +#include "RE/B/BSTArray.h" +#include "RE/B/BSTList.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + struct BGSDebrisData + { + public: + // members + BSTArray unk00; // 00 + BSTArray unk10; // 10 + std::uint64_t unk20; // 20 + BSFixedString unk28; // 28 + }; + static_assert(sizeof(BGSDebrisData) == 0x30); + + class BGSDebris : + public TESForm, // 00 + public BGSPreloadable // 30 + { + public: + SF_RTTI_VTABLE(BGSDebris); + SF_FORMTYPE(DEBR); + + ~BGSDebris() override; // 00 + + // members + BSSimpleList data; // 38 + }; + static_assert(sizeof(BGSDebris) == 0x48); +} diff --git a/CommonLibSF/include/RE/B/BGSDefaultObject.h b/CommonLibSF/include/RE/B/BGSDefaultObject.h new file mode 100644 index 00000000..fdb16670 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSDefaultObject.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSDefaultObject : public TESForm + { + public: + SF_RTTI_VTABLE(BGSDefaultObject); + SF_FORMTYPE(DFOB); + + ~BGSDefaultObject() override; // 00 + + // members + BGSEditorID formEditorID; // 30 + TESForm* object; // 40 + stl::enumeration objectType; // 48 + }; + static_assert(sizeof(BGSDefaultObject) == 0x50); +} diff --git a/CommonLibSF/include/RE/B/BGSDefaultObjectManager.h b/CommonLibSF/include/RE/B/BGSDefaultObjectManager.h new file mode 100644 index 00000000..82eb65ac --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSDefaultObjectManager.h @@ -0,0 +1,448 @@ +#pragma once + +#include "RE/B/BSTSingleton.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + struct DEFAULT_OBJECTS + { + enum DEFAULT_OBJECT + { + kUNUSED01 = 0, + kSittingAngleLimit = 1, + kAllowPlayerShout = 2, + kGold = 3, + kLockpick = 4, + kSkeletonKey = 5, + kPlayerFaction = 6, + kGuardFaction = 7, + kBattleMusic = 8, + kDeathMusic = 9, + kUNUSED07 = 10, + kPlayerVoiceMale = 11, + kPlayerVoiceMaleChild = 12, + kPlayerVoiceFemale = 13, + kPlayerVoiceFemaleChild = 14, + kEatPackageDefaultFood = 15, + kVoiceEquip = 16, + kPotionEquip = 17, + kEveryActorAbility = 18, + kCommandedActorAbility = 19, + kDrugWearsOffImageSpace = 20, + kFootstepSet = 21, + kLandscapeMaterial = 22, + kDragonLandZoneMarker = 23, + kDragonCrashZoneMarker = 24, + kCombatStyle = 25, + kDefaultPackList = 26, + kWaitForDialoguePackage = 27, + kVirtualLocation = 28, + kPersistAllLocation = 29, + kPathingTestNPC = 30, + kActionSwimStateChange = 31, + kActionLook = 32, + kActionLeftAttack = 33, + kActionLeftReady = 34, + kActionLeftRelease = 35, + kActionLeftInterrupt = 36, + kActionRightAttack = 37, + kActionRightReady = 38, + kActionRightRelease = 39, + kActionRightInterrupt = 40, + kActionDualAttack = 41, + kActionDualRelease = 42, + kActionActivate = 43, + kActionJump = 44, + kActionFall = 45, + kActionLand = 46, + kActionMantle = 47, + kActionSneakStart = 48, + kActionSneakStop = 49, + kActionArtifactPower = 50, + kActionArtifactPowerReady = 51, + kActionArtifactPowerRelease = 52, + kActionArtifactPowerInterrupt = 53, + kActionIdle = 54, + kActionSprintStart = 55, + kActionSprintStop = 56, + kActionDraw = 57, + kActionSheath = 58, + kActionLeftPowerAttack = 59, + kActionRightPowerAttack = 60, + kActionDualPowerAttack = 61, + kActionLeftSyncAttack = 62, + kActionRightSyncAttack = 63, + kActionStaggerStart = 64, + kActionBlockHit = 65, + kActionBlockAnticipate = 66, + kActionRecoil = 67, + kActionLargeRecoil = 68, + kActionBleedoutStart = 69, + kActionBleedoutStop = 70, + kActionElectromagneticShockedStart = 71, + kActionElectromagneticShockedStop = 72, + kActionIdleStop = 73, + kActionWardHit = 74, + kActionForceEquip = 75, + kActionShieldChange = 76, + kActionPathStart = 77, + kActionPathEnd = 78, + kActionLargeMovementDelta = 79, + kActionFlyStart = 80, + kActionFlyStop = 81, + kActionHoverStart = 82, + kActionHoverStop = 83, + kActionBumpedInto = 84, + kActionSummonedStart = 85, + kActionDialogueTalking = 86, + kActionDialogueListen = 87, + kActionDialogueEnter = 88, + kActionDialogueExit = 89, + kActionDeath = 90, + kActionDeathWait = 91, + kActionMoveStart = 92, + kActionMoveStop = 93, + kActionTurnRight = 94, + kActionTurnLeft = 95, + kActionTurnStop = 96, + kActionMoveForward = 97, + kActionMoveBackward = 98, + kActionMoveLeft = 99, + kActionMoveRight = 100, + kActionKnockdown = 101, + kActionGetUp = 102, + kActionGravityOff = 103, + kActionGravityOn = 104, + kActionIdleStopInstant = 105, + kActionRagdollInstant = 106, + kActionWaterwalkStart = 107, + kActionReload = 108, + kActionBoltCharge = 109, + kActionSighted = 110, + kActionSightedRelease = 111, + kActionBlindFireStart = 112, + kActionBlindFireStop = 113, + kActionMelee = 114, + kActionFireSingle = 115, + kActionFireCharge = 116, + kActionFireChargeHold = 117, + kActionFireAuto = 118, + kActionFireEmpty = 119, + kActionThrow = 120, + kActionEnterCover = 121, + kActionExitCover = 122, + kActionCoverSprintStart = 123, + kActionShuffle = 124, + kActionPipboy = 125, + kActionPipboyClose = 126, + kActionPipboyZoom = 127, + kActionPipboyStats = 128, + kActionPipboyInventory = 129, + kActionPipboyData = 130, + kActionPipboyMap = 131, + kActionPipboyTab = 132, + kActionPipboyTabPrevious = 133, + kActionPipboySelect = 134, + kActionPipboyRadioOn = 135, + kActionPipboyRadioOff = 136, + kActionPipboyInspect = 137, + kActionNonSupportContact = 138, + kActionInteractionEnter = 139, + kActionInteractionExit = 140, + kActionInteractionExitAlternate = 141, + kActionInteractionExitQuick = 142, + kActionIntimidate = 143, + kActionGunChargeStart = 144, + kActionGunDown = 145, + kActionGunRelaxed = 146, + kActionGunAlert = 147, + kActionGunReady = 148, + kActionFlipThrow = 149, + kActionEnterCombat = 150, + kActionExitCombat = 151, + kActionLimbCritical = 152, + kActionEvade = 153, + kActionDodge = 154, + kActionAvoid = 155, + kActionAoEAttack = 156, + kActionCower = 157, + kActionTunnel = 158, + kActionFleeStart = 159, + kActionHide = 160, + kActionTaunt = 161, + kActionTraversalStart = 162, + kActionTraversalEnd = 163, + kActionFlightTakeoff = 164, + kActionFlightLanding = 165, + kActionStepInTalkingToPlayer = 166, + kActionThreatAssess = 167, + kActionThreatBackDown = 168, + kActionThreatCurious = 169, + kActionThreatIntimidate = 170, + kActionThreatListenBack = 171, + kActionThreatListenFront = 172, + kImagespaceLowHealth = 173, + kKeywordHorse = 174, + kKeywordUndead = 175, + kKeywordNPC = 176, + kUNUSED02 = 177, + kKeywordDummyObject = 178, + kKeywordUseGeometryEmitter = 179, + kKeywordMustStop = 180, + kMaleFaceTextureSetHead = 181, + kMaleFaceTextureSetMouth = 182, + kMaleFaceTextureSetEyes = 183, + kFemaleFaceTextureSetHead = 184, + kFemaleFaceTextureSetMouth = 185, + kFemaleFaceTextureSetEyes = 186, + kImageSpaceModifierForInventoryMenu = 187, + kImageSpaceModifierForPipboyMenuInPowerArmor = 188, + kPackageTemplate = 189, + kMainMenuCell = 190, + kDefaultMovementTypeDefault = 191, + kDefaultMovementTypeSwim = 192, + kDefaultMovementTypeFly = 193, + kDefaultMovementTypeSneak = 194, + kKeywordSpecialFurniture = 195, + kKeywordFurnitureForces1stPerson = 196, + kKeywordFurnitureForces3rdPerson = 197, + kKeywordActivatorFurnitureNoPlayer = 198, + kWorldMapWeather = 199, + kKeywordTypeAmmo = 200, + kKeywordTypeArmor = 201, + kKeywordTypeBook = 202, + kKeywordTypeIngredient = 203, + kKeywordTypeKey = 204, + kKeywordTypeMisc = 205, + kKeywordTypeSoulGem = 206, + kKeywordTypeWeapon = 207, + kKeywordTypePotion = 208, + kBaseWeaponEnchantment = 209, + kBaseArmorEnchantment = 210, + kBasePotion = 211, + kBasePoison = 212, + kKeywordDragon = 213, + kKeywordMovable = 214, + kArtObjectAbsorbEffect = 215, + kWeaponMaterialList = 216, + kArmorMaterialList = 217, + kKeywordDisallowEnchanting = 218, + kFavorTravelMarkerLocation = 219, + kTeammateReadyWeapon = 220, + kKeywordHoldLocation = 221, + kKeywordCivilWarOwner = 222, + kKeywordCivilWarNeutral = 223, + kLocRefTypeCivilWarSoldier = 224, + kUNUSED06 = 225, + kLocRefTypeResourceDestructible = 226, + kFormListHairColorList = 227, + kComplexSceneObject = 228, + kKeywordReusableSoulGem = 229, + kKeywordAnimal = 230, + kKeywordDaedra = 231, + kKeywordRobot = 232, + kKeywordNirnroot = 233, + kFightersGuildFaction = 234, + kMagesGuildFaction = 235, + kThievesGuildFaction = 236, + kDarkBrotherhoodFaction = 237, + kJarlFaction = 238, + kBunnyFaction = 239, + kPlayerIsVampireVariable = 240, + kUNUSED03 = 241, + kRoadMarker = 242, + kKeywordScaleActorTo10 = 243, + kKeywordVampire = 244, + kKeywordForge = 245, + kKeywordCookingPot = 246, + kKeywordSmelter = 247, + kKeywordTanningRack = 248, + kHelpBasicLockpickingPC = 249, + kHelpBasicLockpickingConsole = 250, + kHelpBasicForging = 251, + kHelpBasicCooking = 252, + kHelpBasicSmelting = 253, + kHelpBasicTanning = 254, + kHelpBasicObjectCreation = 255, + kHelpBasicEnchanting = 256, + kHelpBasicSmithingWeapon = 257, + kHelpBasicSmithingArmor = 258, + kHelpBasicAlchemy = 259, + kHelpBarter = 260, + kHelpLevelingUp = 261, + kHelpSkillsMenu = 262, + kHelpMapMenu = 263, + kHelpJournal = 264, + kHelpLowHealth = 265, + kHelpLowMagicka = 266, + kHelpLowStamina = 267, + kHelpJail = 268, + kHelpTeamateFavor = 269, + kHelpWeaponCharge = 270, + kHelpFavorites = 271, + kKinectHelpFormList = 272, + kImagespaceLoadScreen = 273, + kKeywordWeaponMaterialDaedric = 274, + kKeywordWeaponMaterialDraugr = 275, + kKeywordWeaponMaterialDraugrHoned = 276, + kKeywordWeaponMaterialDwarven = 277, + kKeywordWeaponMaterialEbony = 278, + kKeywordWeaponMaterialElven = 279, + kKeywordWeaponMaterialFalmer = 280, + kKeywordWeaponMaterialFalmerHoned = 281, + kKeywordWeaponMaterialGlass = 282, + kKeywordWeaponMaterialImperial = 283, + kKeywordWeaponMaterialIron = 284, + kKeywordWeaponMaterialOrcish = 285, + kKeywordWeaponMaterialSteel = 286, + kKeywordWeaponMaterialWood = 287, + kKeywordWeaponTypeBoundArrow = 288, + kKeywordArmorMaterialDaedric = 289, + kKeywordArmorMaterialDragonplate = 290, + kKeywordArmorMaterialDragonscale = 291, + kKeywordArmorMaterialDragonbone = 292, + kKeywordArmorMaterialDwarven = 293, + kKeywordArmorMaterialEbony = 294, + kKeywordArmorMaterialElven = 295, + kKeywordArmorMaterialElvenSplinted = 296, + kKeywordArmorMaterialFullLeather = 297, + kKeywordArmorMaterialGlass = 298, + kKeywordArmorMaterialHide = 299, + kKeywordArmorMaterialImperial = 300, + kKeywordArmorMaterialImperialHeavy = 301, + kKeywordArmorMaterialImperialReinforced = 302, + kKeywordArmorMaterialIron = 303, + kKeywordArmorMaterialIronBanded = 304, + kKeywordArmorMaterialOrcish = 305, + kKeywordArmorMaterialScaled = 306, + kKeywordArmorMaterialSteel = 307, + kKeywordArmorMaterialSteelPlate = 308, + kKeywordArmorMaterialStormcloak = 309, + kKeywordArmorMaterialStudded = 310, + kKeywordGenericCraftableKeyword01 = 311, + kKeywordGenericCraftableKeyword02 = 312, + kKeywordGenericCraftableKeyword03 = 313, + kKeywordGenericCraftableKeyword04 = 314, + kKeywordGenericCraftableKeyword05 = 315, + kKeywordGenericCraftableKeyword06 = 316, + kKeywordGenericCraftableKeyword07 = 317, + kKeywordGenericCraftableKeyword08 = 318, + kKeywordGenericCraftableKeyword09 = 319, + kKeywordGenericCraftableKeyword10 = 320, + kKeywordNullptrMOD = 321, + kKeywordJewelry = 322, + kKeywordCuirass = 323, + kLocalMapHidePlane = 324, + kSnowLODMaterial = 325, + kSnowLODMaterialHD = 326, + kDialogueImagespace = 327, + kDialogueFollowerQuest = 328, + kPotentialFollowerFaction = 329, + kUnused330 = 330, + kVampireAvailablePerks = 331, + kUnused332 = 332, + kVampireRace = 333, + kVampireSpells = 334, + kKeywordMount = 335, + kVerletCape = 336, + kFurnitureTestNPC = 337, + kKeywordConditionalExplosion = 338, + kDefaultLight1 = 339, + kDefaultLight2 = 340, + kDefaultLight3 = 341, + kDefaultLight4 = 342, + kPipboyLight = 343, + kActionBeginLoopingActivate = 344, + kActionEndLoopingActivate = 345, + kWorkshopPlayerOwnership = 346, + kQuestMarkerFollower = 347, + kQuestMarkerLocation = 348, + kQuestMarkerEnemy = 349, + kQuestMarkerEnemyAbove = 350, + kQuestMarkerEnemyBelow = 351, + kWorkshopMiscItemKeyword = 352, + kHeavyWeaponItemKeyword = 353, + kMineItemKeyword = 354, + kGrenadeItemKeyword = 355, + kChemItemKeyword = 356, + kAlcoholItemKeyword = 357, + kFoodItemKeyword = 358, + kRepairKitItemKeyword = 359, + kMedBagItemKeyword = 360, + kGlovesItemKeyword = 361, + kHelmetItemKeyword = 362, + kClothesItemKeyword = 363, + + kTotal = 364 + }; + }; + using DEFAULT_OBJECT = DEFAULT_OBJECTS::DEFAULT_OBJECT; + + enum class DEFAULT_OBJECT_TYPE + { + kMisc, + kFacegen, + kMovement, + kActions, + kItems, + kSounds, + kKeywords + }; + + struct DEFAULT_OBJECT_DATA + { + public: + // members + const char* name; // 00 + stl::enumeration type; // 08 + char uniqueID[4]; // 0C + stl::enumeration doType; // 10 + const char* newObjectName; // 18 + }; + static_assert(sizeof(DEFAULT_OBJECT_DATA) == 0x20); + + [[nodiscard]] inline std::span GetDefaultObjectData() + { + REL::Relocation data{ REL::ID(761776) }; + return { *data }; + } + + class BGSDefaultObjectManager : + public TESForm, // 00 + public BSTSingletonImplicit // 30 + { + public: + SF_RTTI_VTABLE(BGSDefaultObjectManager); + SF_FORMTYPE(DOBJ); + + [[nodiscard]] static BGSDefaultObjectManager* GetSingleton() + { + using func_t = decltype(&BGSDefaultObjectManager::GetSingleton); + REL::Relocation func{ REL::ID(82283) }; + return func(); + } + + ~BGSDefaultObjectManager() override; // 00 + + [[nodiscard]] TESForm* GetDefaultObject(DEFAULT_OBJECT a_obj) const noexcept + { + assert(a_obj < DEFAULT_OBJECT::kTotal); + return objectArray[stl::to_underlying(a_obj)]; + } + + template + [[nodiscard]] T* GetDefaultObject(DEFAULT_OBJECT a_obj) const // + requires(std::derived_from && + !std::is_pointer_v && + !std::is_reference_v) + { + const auto obj = GetDefaultObject(a_obj); + return obj ? obj->As() : nullptr; + } + + // members + TESForm* objectArray[DEFAULT_OBJECTS::kTotal]; // 030 + }; + static_assert(sizeof(BGSDefaultObjectManager) == 0xB90); +} diff --git a/CommonLibSF/include/RE/B/BGSDirectionalAmbientLightingColors.h b/CommonLibSF/include/RE/B/BGSDirectionalAmbientLightingColors.h new file mode 100644 index 00000000..e46c8d15 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSDirectionalAmbientLightingColors.h @@ -0,0 +1,34 @@ +#pragma once + +#include "RE/C/Color.h" + +namespace RE +{ + class BGSDirectionalAmbientLightingColors + { + public: + struct Directional + { + public: + template + struct MaxMin + { + public: + // members + T max; // 0 + T min; // ? + }; + static_assert(sizeof(MaxMin) == 0x8); + + // members + MaxMin x; // 00 + MaxMin y; // 08 + MaxMin z; // 10 + }; + static_assert(sizeof(Directional) == 0x18); + + // members + Directional directional; // 00 + }; + static_assert(sizeof(BGSDirectionalAmbientLightingColors) == 0x18); +} diff --git a/CommonLibSF/include/RE/B/BGSEffectSequenceForm.h b/CommonLibSF/include/RE/B/BGSEffectSequenceForm.h new file mode 100644 index 00000000..9e88beb3 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSEffectSequenceForm.h @@ -0,0 +1,50 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + namespace BSSequence + { + class Sequence; + + class NamedSequenceMap + { + public: + virtual ~NamedSequenceMap(); // 00 + + // add + virtual void Unk_01(); // 01 + virtual void Unk_02(); // 02 + + // members + /*std::set>>*/ std::uint8_t sequences[0x30]; // 08 + }; + static_assert(sizeof(NamedSequenceMap) == 0x38); + } + + class EffectSequenceMap : public BSSequence::NamedSequenceMap + { + public: + ~EffectSequenceMap() override; // 00 + + // members + BGSEffectSequenceForm* parent; // 38 + BSTArray unk40; // 40 + std::uint8_t unk50; // 50 + }; + static_assert(sizeof(EffectSequenceMap) == 0x58); + + class BGSEffectSequenceForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSEffectSequenceForm); + SF_FORMTYPE(EFSQ); + + ~BGSEffectSequenceForm() override; // 00 + + // members + EffectSequenceMap map; // 30 + }; + static_assert(sizeof(BGSEffectSequenceForm) == 0x88); +} diff --git a/CommonLibSF/include/RE/B/BGSFogVolumeForm.h b/CommonLibSF/include/RE/B/BGSFogVolumeForm.h new file mode 100644 index 00000000..b4d40b1b --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSFogVolumeForm.h @@ -0,0 +1,29 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + class BGSFogVolumeForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSFogVolumeForm); + SF_FORMTYPE(FOGV); + + ~BGSFogVolumeForm() override; // 00 + + // members + DirectX::XMCOLOR albedo; // 30 + float meanFreePath; // 34 - how far light can travel freely in meters [1, infinite] + float anisotropy; // 38 + DirectX::XMFLOAT3 emittance; // 3C + float edgeFalloffStart; // 48 + float edgeFalloffEnd; // 4C + float noiseContribution; // 50 + float noiseScale; // 54 + float noiseBias; // 58 + DirectX::XMFLOAT3 noiseScrollingVelocity; // 5C + std::uint32_t pad68; // 68 + }; + static_assert(sizeof(BGSFogVolumeForm) == 0x70); +} diff --git a/CommonLibSF/include/RE/B/BGSFootstep.h b/CommonLibSF/include/RE/B/BGSFootstep.h new file mode 100644 index 00000000..73e03818 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSFootstep.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSImpactDataSet; + + class BGSFootstep : public TESForm + { + public: + SF_RTTI_VTABLE(BGSFootstep); + SF_FORMTYPE(FSTP); + + ~BGSFootstep() override; // 00 + + // members + BSFixedString tag; // 30 - ANAM + BGSImpactDataSet* impactSet; // 38 - DATA + }; + static_assert(sizeof(BGSFootstep) == 0x40); +} diff --git a/CommonLibSF/include/RE/B/BGSFootstepSet.h b/CommonLibSF/include/RE/B/BGSFootstepSet.h new file mode 100644 index 00000000..af18555f --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSFootstepSet.h @@ -0,0 +1,37 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSFootstep; + + struct ACTOR_MOVEMENT_TYPES + { + enum ACTOR_MOVEMENT_TYPE : std::uint32_t + { + kWalk = 0, + kRun = 1, + kSneak = 2, + kBleedout = 3, + kSwim = 4, + + kTotal = 5 + }; + }; + using ACTOR_MOVEMENT_TYPE = ACTOR_MOVEMENT_TYPES::ACTOR_MOVEMENT_TYPE; + + class BGSFootstepSet : public TESForm + { + public: + SF_RTTI_VTABLE(BGSFootstepSet); + SF_FORMTYPE(FSTS); + + ~BGSFootstepSet() override; // 00 + + // members + BSTArray entries[ACTOR_MOVEMENT_TYPES::kTotal]; // 30 + }; + static_assert(sizeof(BGSFootstepSet) == 0x80); +} diff --git a/CommonLibSF/include/RE/B/BGSForceData.h b/CommonLibSF/include/RE/B/BGSForceData.h new file mode 100644 index 00000000..b3a7b046 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSForceData.h @@ -0,0 +1,47 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + class BGSCurveForm; + + namespace BSForces + { + enum class TYPE + { + kDirectional, + kPoint + }; + + enum class CHANNEL + { + kGravity, + kWind + }; + } + + class BGSForceData : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSForceData); + SF_FORMTYPE(FORC); + + ~BGSForceData() override; // 00 + + // members + stl::enumeration forceType; // 30 + stl::enumeration forceChannel; // 34 + float horizontalAngle; // 38 + float verticalAngle; // 3C + float speed; // 40 + float strength; // 44 + DirectX::XMFLOAT3 vector; // 48 + BGSCurveForm* falloffCurve; // 58 + float turbulenceSpeedAmplitude; // 60 + float turbulenceSpeedFrequency; // 64 + float turbulenceDirectionAmplitude; // 68 + float turbulenceDirectionFrequency; // 6C + }; + static_assert(sizeof(BGSForceData) == 0x70); +} diff --git a/CommonLibSF/include/RE/B/BGSGenericBaseFormTemplate.h b/CommonLibSF/include/RE/B/BGSGenericBaseFormTemplate.h new file mode 100644 index 00000000..0ca308ed --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSGenericBaseFormTemplate.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSGenericBaseFormTemplate : public TESForm + { + public: + SF_RTTI_VTABLE(BGSGenericBaseFormTemplate); + SF_FORMTYPE(GBFT); + + // members + BGSEditorID formEditorID; // 30 + BSTArray components; // 40 + }; + static_assert(sizeof(BGSGenericBaseFormTemplate) == 0x50); +} diff --git a/CommonLibSF/include/RE/B/BGSGroundCover.h b/CommonLibSF/include/RE/B/BGSGroundCover.h new file mode 100644 index 00000000..0a939639 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSGroundCover.h @@ -0,0 +1,31 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESGrass; + + class BGSGroundCover : public TESForm + { + public: + SF_RTTI_VTABLE(BGSGroundCover); + SF_FORMTYPE(GCVR); + + ~BGSGroundCover() override; // 00 + + // members + std::uint64_t unk30; // 30 + std::uint64_t unk38; // 38 + std::uint64_t unk40; // 40 + std::uint64_t unk48; // 48 + std::uint64_t unk50; // 50 + std::uint64_t unk58; // 58 + std::uint64_t unk60; // 60 + std::uint64_t unk68; // 68 + std::uint64_t unk70; // 70 + std::uint64_t unk78; // 78 + std::uint32_t unk80; // 80 + }; + static_assert(sizeof(BGSGroundCover) == 0x88); +} diff --git a/CommonLibSF/include/RE/B/BGSHeadPart.h b/CommonLibSF/include/RE/B/BGSHeadPart.h new file mode 100644 index 00000000..324fe30a --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSHeadPart.h @@ -0,0 +1,65 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSModelMaterialSwap.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESModelTri.h" + +namespace RE +{ + class BGSMorphableObject; + class BGSListForm; + class BGSTextureSet; + + class BGSHeadPart : + public TESForm, // 000 + public TESFullName, // 030 + public BGSModelMaterialSwap // 040 + { + public: + SF_RTTI_VTABLE(BGSHeadPart); + SF_FORMTYPE(HDPT); + + enum class HeadPartType + { + kMisc, + kFace, + kEyeRight, + kHair, + kFacialHair, + kScar, + kEyebrows, + kJewelry, + kMeatcaps, + kTeeth, + kHeadRear, + kExtraHair, + kEyeLeft, + kEyelashes, + kCreatureHead, + kCreatureTorso, + kCreatureArms, + kCreatureLegs, + kCreatureTail, + kCreatureWings + }; + + // members + BGSEditorID formEditorID; // 068 + TESModel chargenModel; // 078 + TESModelTri morphs[3]; // 098 + TESCondition chargenConditions; // 0F8 + BSTArray extraParts; // 108 + BGSMorphableObject* morphableObject; // 118 + BGSTextureSet* textureSet; // 120 + BGSListForm* validRaces; // 128 + BSFixedString colorMapping; // 130 + BSFixedString mask; // 138 + stl::enumeration type; // 140 + std::uint32_t unk144; // 144 + }; + static_assert(sizeof(BGSHeadPart) == 0x148); +} diff --git a/CommonLibSF/include/RE/B/BGSImpactData.h b/CommonLibSF/include/RE/B/BGSImpactData.h new file mode 100644 index 00000000..b0c6f412 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSImpactData.h @@ -0,0 +1,66 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/D/DecalData.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESModel.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + enum class ImpactResult; + + class BGSExplosion; + class BGSHazard; + class BGSProjectedDecal; + + class BGSImpactData : + public TESForm, // 00 + public TESModel // 30 + { + public: + SF_RTTI_VTABLE(BGSImpactData); + SF_FORMTYPE(IPCT); + + enum class ORIENTATION + { + kSurfaceNormal = 0, + kProjVector = 1, + kProjReflect = 2 + }; + + struct IMPACT_DATA_DATA // DATA + { + enum class Flag + { + kNone = 0, + kNoDecalData = 1 << 0 + }; + + float effectDuration; // 00 + stl::enumeration orient; // 04 + float angleThreshold; // 08 + float placementRadius; // 0C + std::uint32_t soundLevel; // 10 + stl::enumeration flags; // 14 + stl::enumeration resultOverride; // 15 + }; + static_assert(sizeof(IMPACT_DATA_DATA) == 0x18); + + ~BGSImpactData() override; // 00 + + // members + IMPACT_DATA_DATA data; // 050 + DecalData decalData; // 068 + BSTArray projectedDecals1; // 080 + BSTArray projectedDecals2; // 090 + BGSAudio::WwiseSoundHook sound1; // 0A0 + BGSAudio::WwiseSoundHook sound2; // 0D0 + BGSAudio::WwiseSoundHook sound3; // 100 + BGSExplosion* explosion; // 130 + BGSHazard* hazard; // 138 + float maxFootstepParticleDist; // 140 + std::uint32_t unk144; // 144 + }; + static_assert(sizeof(BGSImpactData) == 0x148); +} diff --git a/CommonLibSF/include/RE/B/BGSImpactDataSet.h b/CommonLibSF/include/RE/B/BGSImpactDataSet.h new file mode 100644 index 00000000..1389916c --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSImpactDataSet.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BGSPreloadable.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSImpactDataSet : + public TESForm, // 00 + public BGSPreloadable // 30 + { + public: + SF_RTTI_VTABLE(BGSImpactDataSet); + SF_FORMTYPE(IPDS); + + ~BGSImpactDataSet() override; // 00 + + // members + std::uint8_t impactMap[0x28]; // 38 + }; + static_assert(sizeof(BGSImpactDataSet) == 0x60); +} diff --git a/CommonLibSF/include/RE/B/BGSInstanceNamingRules.h b/CommonLibSF/include/RE/B/BGSInstanceNamingRules.h new file mode 100644 index 00000000..9136ca71 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSInstanceNamingRules.h @@ -0,0 +1,45 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLocalizedString.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSInstanceNamingRules : public TESForm + { + public: + SF_RTTI_VTABLE(BGSInstanceNamingRules); + SF_FORMTYPE(INNR); + + class RuleData + { + public: + // members + BGSLocalizedString text; // 00 + BGSKeywordForm keywords; // 08 + float compareVal; // 38 + std::int8_t propertyBridgeArrayIndex; // 3C + std::int8_t operatorType; // 3D + std::uint16_t index; // 3E + bool revert; // 40 + }; + static_assert(sizeof(RuleData) == 0x48); + + struct RuleSet : + public BSTArray // 00 + { + public: + }; + static_assert(sizeof(RuleSet) == 0x10); + + ~BGSInstanceNamingRules() override; // 00 + + // members + stl::enumeration type; // 30 + RuleSet rules[10]; // 38 + BSTArray mergeSources; // D8 + }; + static_assert(sizeof(BGSInstanceNamingRules) == 0xE8); +} diff --git a/CommonLibSF/include/RE/B/BGSLayeredMaterialSwap.h b/CommonLibSF/include/RE/B/BGSLayeredMaterialSwap.h new file mode 100644 index 00000000..dddd16af --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSLayeredMaterialSwap.h @@ -0,0 +1,38 @@ +#pragma once + +#include "RE/B/BGSKeyword.h" +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSTArray.h" + +namespace RE +{ + class BGSLayeredMaterialSwap : + public BGSReflectedForm, // 00 + public BSTEventSink // 30 + { + public: + SF_RTTI_VTABLE(BGSLayeredMaterialSwap); + SF_FORMTYPE(LMSW); + + enum class SOURCE + { + kNone = 0, + kModelOnly = 1, + kRefDefined = 2, + kBiome = 3, + kObjectTemplate = 4, + kSkin = 5, + kPackin = 6 + }; + + struct Entry; + + ~BGSLayeredMaterialSwap() override; // 00 + + // members + BSTArray keywords; // 38 + BSTArray entries; // 48 + BSTArray swapCollection; // 58 + }; + static_assert(sizeof(BGSLayeredMaterialSwap) == 0x68); +} diff --git a/CommonLibSF/include/RE/B/BGSLensFlare.h b/CommonLibSF/include/RE/B/BGSLensFlare.h new file mode 100644 index 00000000..9106e975 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSLensFlare.h @@ -0,0 +1,41 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/B/BSTSmartPointer.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + namespace BSLensFlareRender + { + class BSLensFlareSpriteRenderData; + + class BSLensFlareRenderData + { + public: + // members + float unk00; // 00 + float unk04; // 04 + float unk08; // 08 + float unk0C; // 0C + float unk10; // 10 + std::uint8_t unk14; // 14 + BSTArray> lensSprites; // 18 + std::uint64_t unk28; // 28 + float unk30; // 30 + }; + static_assert(sizeof(BSLensFlareRenderData) == 0x38); + } + + class BGSLensFlare : + public TESForm, // 00 + public BSLensFlareRender::BSLensFlareRenderData // 30 + { + public: + SF_RTTI_VTABLE(BGSLensFlare); + SF_FORMTYPE(LENS); + + ~BGSLensFlare() override; // 00 + }; + static_assert(sizeof(BGSLensFlare) == 0x68); +} diff --git a/CommonLibSF/include/RE/B/BGSLightingTemplate.h b/CommonLibSF/include/RE/B/BGSLightingTemplate.h new file mode 100644 index 00000000..8b2d8eb2 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSLightingTemplate.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BGSDirectionalAmbientLightingColors.h" +#include "RE/I/InteriorData.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSLightingTemplate : public TESForm + { + public: + SF_RTTI_VTABLE(BGSLightingTemplate); + SF_FORMTYPE(LGTM); + + ~BGSLightingTemplate() override; // 00 + + // members + INTERIOR_DATA data; // 30 + BGSDirectionalAmbientLightingColors directionalAmbientLightingColors; // A8 + }; + static_assert(sizeof(BGSLightingTemplate) == 0xC0); +} diff --git a/CommonLibSF/include/RE/B/BGSMaterialPathForm.h b/CommonLibSF/include/RE/B/BGSMaterialPathForm.h new file mode 100644 index 00000000..12c1a7f4 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSMaterialPathForm.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + class BGSMaterialPathForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSMaterialPathForm); + SF_FORMTYPE(MTPT); + + ~BGSMaterialPathForm() override; // 00 + + // members + BSFixedString material; // 30 - Part of or full relative path to a material + }; + static_assert(sizeof(BGSMaterialPathForm) == 0x38); +} diff --git a/CommonLibSF/include/RE/B/BGSMaterialType.h b/CommonLibSF/include/RE/B/BGSMaterialType.h new file mode 100644 index 00000000..66208dd5 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSMaterialType.h @@ -0,0 +1,39 @@ +#pragma once + +#include "RE/B/BSFixedString.h" +#include "RE/N/NiColor.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESModel.h" + +namespace RE +{ + class BGSImpactDataSet; + + class BGSMaterialType : public TESForm + { + public: + SF_RTTI_VTABLE(BGSMaterialType); + SF_FORMTYPE(MATT); + + enum class FLAG + { + kNone = 0, + kStairs = 1 << 0, + kArrowsStick = 1 << 1, + kCanTunnel = 1 << 2 + }; + + ~BGSMaterialType() override; // 00 + + // members + TESModel breakableFXModel; // 30 + BGSMaterialType* parentType; // 50 + BGSImpactDataSet* havokImpactDataSet; // 58 + BSFixedString materialName; // 60 + std::uint32_t materialID; // 68 + NiColor materialColor; // 6C + float buoyancy; // 78 + stl::enumeration flags; // 7C + }; + static_assert(sizeof(BGSMaterialType) == 0x80); +} diff --git a/CommonLibSF/include/RE/B/BGSMessage.h b/CommonLibSF/include/RE/B/BGSMessage.h new file mode 100644 index 00000000..6426c7d4 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSMessage.h @@ -0,0 +1,54 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESDescription.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class TESObjectREFR; + class TESQuest; + + class BGSMessage : + public TESForm, // 00 + public TESFullName, // 38 + public TESDescription // 48 + { + public: + SF_RTTI_VTABLE(BGSMessage); + SF_FORMTYPE(MESG); + + enum class MessageFlag + { + kNone = 0, + kMessageBox = 1 << 0, + kInitialDelay = 1 << 1 + }; + + struct MESSAGEBOX_BUTTON + { + public: + // members + BSFixedString text; // 00 + BSFixedString unk08; // 08 + TESObjectREFR* reference; // 10 + TESCondition conditions; // 18 + }; + static_assert(sizeof(MESSAGEBOX_BUTTON) == 0x28); + + ~BGSMessage() override; // 00 + + // members + TESQuest* ownerQuest; // 58 + BSTArray menuButtons; // 60 + BSFixedStringCS unk70; // 70 + BGSLocalizedString shortName; // 78 + stl::enumeration flags; // 80 + std::uint32_t displayTime; // 84 + std::int32_t unk88; // 88 + BSFixedStringCS unk90; // 90 + }; + static_assert(sizeof(BGSMessage) == 0x98); +} diff --git a/CommonLibSF/include/RE/B/BGSMod.h b/CommonLibSF/include/RE/B/BGSMod.h index 80275174..1896ff61 100644 --- a/CommonLibSF/include/RE/B/BGSMod.h +++ b/CommonLibSF/include/RE/B/BGSMod.h @@ -1,29 +1,83 @@ #pragma once +#include "RE/B/BGSAttachParentArray.h" #include "RE/B/BSTArray.h" #include "RE/B/BaseFormComponent.h" +#include "RE/T/TESDescription.h" +#include "RE/T/TESFullName.h" -namespace RE::BGSMod::Template +namespace RE { - class Items : public BaseFormComponent + class BGSKeyword; + class BGSMorphableObject; +} + +namespace RE::BGSMod +{ + namespace Attachment + { + class Mod : + public TESForm, // 00 + public TESFullName, // 30 + public TESDescription, // 40 + public BGSModelMaterialSwap // 58 + { + public: + SF_RTTI_VTABLE(BGSMod__Attachment__Mod); + SF_FORMTYPE(OMOD); + + struct Data + { + public: + // members + BSTArray includes; // 00 + BSTArray properties; // 10 + }; + static_assert(sizeof(Data) == 0x20); + + ~Mod() override; // 00 + + // members + Data data; // 80 + BGSAttachParentArray attachParents; // A0 + std::uint64_t unkC0; // C0 - std::vector? + std::uint64_t unkC8; // C8 + std::uint64_t unkD0; // D0 + BGSKeyword* attachPoint; // D8 + BGSMorphableObject* unkE0; // E0 + BGSMorphableObject* unkE8; // E8 + BSFixedString name; // F0 + std::uint8_t unkF8; // F8 + std::uint8_t unkF9; // F9 + std::uint8_t priority; // FA + std::uint8_t unkFB; // FB + std::uint8_t unkFC; // FC + }; + static_assert(sizeof(Mod) == 0x100); + } + + namespace Template { - public: - SF_RTTI_VTABLE(BGSMod__Template__Items); + class Items : public BaseFormComponent + { + public: + SF_RTTI_VTABLE(BGSMod__Template__Items); - virtual ~Items() override; + ~Items() override; // 00 - // override (BaseFormComponent) - const BSFixedString& GetFormComponentType() const override; // 01 - { return "BGSMod_Template_Component"; } - void InitializeDataComponent() override; // 02 + // override (BaseFormComponent) + const BSFixedString& GetFormComponentType() const override; // 01 - { return "BGSMod_Template_Component"; } + void InitializeDataComponent() override; // 02 - // add - virtual void Unk_0B(); // 0B - virtual void Unk_0C(); // 0C - virtual void Unk_0D(); // 0D + // add + virtual void Unk_0B(); // 0B + virtual void Unk_0C(); // 0C + virtual void Unk_0D(); // 0D - // members - BSTArray unk08; // 08 - BSFixedString unk18; // 18 - }; - static_assert(sizeof(Items) == 0x20); + // members + BSTArray unk08; // 08 + BSFixedString unk18; // 18 + }; + static_assert(sizeof(Items) == 0x20); + } } diff --git a/CommonLibSF/include/RE/B/BGSMorphableObject.h b/CommonLibSF/include/RE/B/BGSMorphableObject.h new file mode 100644 index 00000000..ef615a2c --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSMorphableObject.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSMorphableObject : public TESForm + { + public: + SF_RTTI_VTABLE(BGSMorphableObject); + SF_FORMTYPE(MRPH); + + ~BGSMorphableObject() override; // 00 + + // members + BGSEditorID formEditorID; // 30 + BSFixedString performanceMorph; // 40 + BSFixedString chargenMorph; // 48 + BSFixedString unk50; // 50 + std::uint32_t unk58; // 58 + }; + static_assert(sizeof(BGSMorphableObject) == 0x60); +} diff --git a/CommonLibSF/include/RE/B/BGSMovementType.h b/CommonLibSF/include/RE/B/BGSMovementType.h new file mode 100644 index 00000000..40036c70 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSMovementType.h @@ -0,0 +1,17 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/W/WwiseGUID.h" + +namespace RE +{ + class BGSMovementType : public TESForm + { + public: + SF_RTTI_VTABLE(BGSMovementType); + SF_FORMTYPE(MOVT); + + ~BGSMovementType() override; // 00 + }; + //static_assert(sizeof(BGSMovementType) == 0x140); +} diff --git a/CommonLibSF/include/RE/B/BGSObjectSwap.h b/CommonLibSF/include/RE/B/BGSObjectSwap.h new file mode 100644 index 00000000..6c464ea0 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSObjectSwap.h @@ -0,0 +1,23 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSObjectSwap : public TESForm + { + public: + SF_RTTI_VTABLE(BGSObjectSwap); + SF_FORMTYPE(OSWP); + + ~BGSObjectSwap() override; // 00 + + // members + std::uint64_t unk30; // 30 + std::uint64_t unk38; // 38 + std::uint64_t unk40; // 40 + std::uint64_t unk48; // 48 + std::uint64_t unk50; // 50 + }; + static_assert(sizeof(BGSObjectSwap) == 0x58); +} diff --git a/CommonLibSF/include/RE/B/BGSParticleSystemDefineCollection.h b/CommonLibSF/include/RE/B/BGSParticleSystemDefineCollection.h new file mode 100644 index 00000000..b38860f6 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSParticleSystemDefineCollection.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSBlendable.h" +#include "RE/B/BSTArray.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class ParticleSystemDefine; + + class BGSParticleSystemDefineCollection : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSParticleSystemDefineCollection); + SF_FORMTYPE(PSDC); + + ~BGSParticleSystemDefineCollection() override; // 00 + + // members + std::vector defines; // 30 + }; + static_assert(sizeof(BGSParticleSystemDefineCollection) == 0x48); +} diff --git a/CommonLibSF/include/RE/B/BGSPersistentIDsForm.h b/CommonLibSF/include/RE/B/BGSPersistentIDsForm.h new file mode 100644 index 00000000..a0f62586 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSPersistentIDsForm.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE::TESDataHandlerPersistentCreatedUtil +{ + class BGSPersistentIDsForm : public TESForm + { + public: + SF_RTTI_VTABLE(TESDataHandlerPersistentCreatedUtil__BGSPersistentIDsForm); + SF_FORMTYPE(PERS); + + ~BGSPersistentIDsForm() override; // 00 + + // members + std::uint64_t unk30; // 30 + std::uint64_t unk38; // 38 + }; + static_assert(sizeof(BGSPersistentIDsForm) == 0x40); +} diff --git a/CommonLibSF/include/RE/B/BGSPhotoModeFeature.h b/CommonLibSF/include/RE/B/BGSPhotoModeFeature.h new file mode 100644 index 00000000..166a96e5 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSPhotoModeFeature.h @@ -0,0 +1,49 @@ +#pragma once + +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESTexture.h" + +namespace RE +{ + class TESImageSpaceModifier; + + class BGSPhotoModeFeature : + public TESForm, // 000 + public TESFullName // 030 + { + public: + SF_RTTI_VTABLE(BGSPhotoModeFeature); + SF_FORMTYPE(PMFT); + + enum class TYPE + { + kTextureOverlay, + kFrame, + kFilter + }; + + struct Feature + { + stl::enumeration type; // 00 + float offsetX; // 04 + float offsetY; // 08 + float unk0C; // 0C + float unk10; // 10 + float width; // 14 + float height; // 18 + float unk1C; // 1C + }; + static_assert(sizeof(Feature) == 0x20); + + ~BGSPhotoModeFeature() override; // 00 + + // members + TESCondition conditions; // 40 + TESImageSpaceModifier* imageSpace; // 50 + TESTexture texture; // 58 + Feature feature; // 68 + }; + static_assert(sizeof(BGSPhotoModeFeature) == 0x88); +} diff --git a/CommonLibSF/include/RE/B/BGSPlanetData.h b/CommonLibSF/include/RE/B/BGSPlanetData.h new file mode 100644 index 00000000..44856db0 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSPlanetData.h @@ -0,0 +1,32 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + namespace BGSSurface + { + class Tree; + } + + namespace BGSPlanet + { + class PlanetData : public TESForm + { + public: + SF_RTTI_VTABLE(BGSPlanet__PlanetData); + SF_FORMTYPE(PNDT); + + ~PlanetData() override; // 00 + + // members + BGSSurface::Tree* surfaceTree; // 30 + std::uint64_t unk38; // 38 + std::uint32_t unk40; // 40 + std::uint32_t unk44; // 44 + std::uint32_t unk48; // 48 + std::uint32_t unk4C; // 4C + }; + static_assert(sizeof(PlanetData) == 0x50); + } +} diff --git a/CommonLibSF/include/RE/B/BGSReferenceGroup.h b/CommonLibSF/include/RE/B/BGSReferenceGroup.h new file mode 100644 index 00000000..7e530698 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSReferenceGroup.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/B/BSStringT.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSReferenceGroup : public TESForm + { + public: + SF_RTTI_VTABLE(BGSReferenceGroup); + SF_FORMTYPE(RFGP); + + ~BGSReferenceGroup() override; // 00 + + // memebrs + BSStringT unk30; // 30 + float unk40; // 40 + std::uint32_t unk48; // 48 + std::uint32_t unk4C; // 4C + std::uint32_t unk50; // 50 - TESPointerHandle + std::uint32_t unk54; // 54 - TESPointerHandle + std::uint64_t unk58; // 58 + std::uint32_t unk60; // 60 + }; + static_assert(sizeof(BGSReferenceGroup) == 0x68); +} diff --git a/CommonLibSF/include/RE/B/BGSResource.h b/CommonLibSF/include/RE/B/BGSResource.h new file mode 100644 index 00000000..00d6fb26 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSResource.h @@ -0,0 +1,45 @@ +#pragma once + +#include "RE/B/BGSCraftingUseSound.h" +#include "RE/B/BGSEditorID.h" +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLocalizedString.h" +#include "RE/B/BSTArray.h" +#include "RE/N/NiColor.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class ActorValueInfo; + class BGSConstructibleObject; + class TESBoundObject; + class TESGlobal; + + class BGSResource : + public TESForm, // 00 + public TESFullName, // 30 + public BGSKeywordForm, // 40 + public BGSCraftingUseSound // 70 + { + public: + SF_RTTI_VTABLE(BGSResource); + SF_FORMTYPE(IRES); + + ~BGSResource() override; // 00 + + // members + BGSEditorID formEditorID; // 0A8 + BSTArray nextRarities; // 0B8 + BGSLocalizedString shortName; // 0C8 + BSFixedString unkD0; // 0D0 + NiColor surfaceColor; // 0D8 + std::uint32_t unkE4; // 0E4 + TESBoundObject* itemList; // 0E8 + ActorValueInfo* actorValue; // 0F0 + TESGlobal* interval; // 0F8 + BGSConstructibleObject* produce; // 100 + std::uint8_t unk108; // 108 + }; + static_assert(sizeof(BGSResource) == 0x110); +} diff --git a/CommonLibSF/include/RE/B/BGSResourceGenerationData.h b/CommonLibSF/include/RE/B/BGSResourceGenerationData.h new file mode 100644 index 00000000..d18955c6 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSResourceGenerationData.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSResourceGenerationData : public TESForm + { + public: + SF_RTTI_VTABLE(BGSResourceGenerationData); + SF_FORMTYPE(RSGD); + + ~BGSResourceGenerationData() override; // 00 + + // members + BSTArray unk30; // 30 + }; + static_assert(sizeof(BGSResourceGenerationData) == 0x40); +} diff --git a/CommonLibSF/include/RE/B/BGSReverbParameters.h b/CommonLibSF/include/RE/B/BGSReverbParameters.h new file mode 100644 index 00000000..91eec645 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSReverbParameters.h @@ -0,0 +1,31 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/W/WwiseGUID.h" + +namespace RE +{ + class BGSReverbParameters : public TESForm + { + public: + SF_RTTI_VTABLE(BGSReverbParameters); + SF_FORMTYPE(REVB); + + enum class ReverbClass + { + kDefault, + kClassA, + kClassB, + kClassC, + kClassD, + kClassE + }; + + ~BGSReverbParameters() override; // 00 + + // members + stl::enumeration reverbClass; // 30 + BGSAudio::WwiseGUID audioBus; // 38 + }; + static_assert(sizeof(BGSReverbParameters) == 0x48); +} diff --git a/CommonLibSF/include/RE/B/BGSSecondaryDamageList.h b/CommonLibSF/include/RE/B/BGSSecondaryDamageList.h new file mode 100644 index 00000000..62b25ccd --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSecondaryDamageList.h @@ -0,0 +1,32 @@ +#pragma once + +#include "RE/B/BSTList.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class ActorValueInfo; + class BGSDamageType; + + struct SECONDARY_DAMAGE + { + public: + // members + BGSDamageType* damageType; // 00 + ActorValueInfo* actorValue; // 08 + }; + static_assert(sizeof(SECONDARY_DAMAGE) == 0x10); + + class BGSSecondaryDamageList : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSecondaryDamageList); + SF_FORMTYPE(SDLT); + + ~BGSSecondaryDamageList() override; // 00 + + // members + BSSimpleList secondaryDamages; // 30 + }; + static_assert(sizeof(BGSSecondaryDamageList) == 0x48); +} diff --git a/CommonLibSF/include/RE/B/BGSShaderParticleGeometryData.h b/CommonLibSF/include/RE/B/BGSShaderParticleGeometryData.h new file mode 100644 index 00000000..26fa8669 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSShaderParticleGeometryData.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + union SETTING_VALUE + { + float f; + std::uint32_t i; + }; + static_assert(sizeof(SETTING_VALUE) == 0x4); + + class BGSShaderParticleGeometryData : public TESForm + { + public: + SF_RTTI_VTABLE(BGSShaderParticleGeometryData); + SF_FORMTYPE(SPGD); + + ~BGSShaderParticleGeometryData() override; // 00 + + // members + BSTArray data; // 30 + BSFixedString particleTexture; // 40 + }; + static_assert(sizeof(BGSShaderParticleGeometryData) == 0x48); +} diff --git a/CommonLibSF/include/RE/B/BGSSnapBehavior.h b/CommonLibSF/include/RE/B/BGSSnapBehavior.h new file mode 100644 index 00000000..f9d85e8f --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSnapBehavior.h @@ -0,0 +1,37 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSKeyword; + class BGSSnapTemplateNode; + + struct SNAP_BEHAVIOR_DATA + { + public: + // members + TESCondition conditions; // 00 + TESForm* baseObject; // 10 + BGSSnapTemplateNode* snapTemplateNode; // 18 + BGSKeyword* keyword; // 20 + BSFixedString unk28; // 28 + std::uint32_t unk30; // 30 + }; + static_assert(sizeof(SNAP_BEHAVIOR_DATA) == 0x38); + + class BGSSnapBehavior : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSnapBehavior); + SF_FORMTYPE(STBH); + + ~BGSSnapBehavior() override; // 00 + + // members + BSTArray snapBehaviors; // 30 + }; + static_assert(sizeof(BGSSnapBehavior) == 0x40); +} diff --git a/CommonLibSF/include/RE/B/BGSSnapTemplate.h b/CommonLibSF/include/RE/B/BGSSnapTemplate.h new file mode 100644 index 00000000..d4711572 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSnapTemplate.h @@ -0,0 +1,44 @@ +#pragma once + +#include "RE/B/BGSPreviewTransform.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSSnapBehavior; + + class BGSSnapTemplate : + public TESForm, // 00 + public BGSPreviewTransform // 30 + { + public: + SF_RTTI_VTABLE(BGSSnapTemplate); + SF_FORMTYPE(STMP); + + ~BGSSnapTemplate() override; // 00 + + // members + std::uint64_t unk078; // 078 + std::uint64_t unk080; // 080 + std::uint64_t unk088; // 088 + std::uint64_t unk090; // 090 + std::uint64_t unk098; // 098 + std::uint64_t unk0A0; // 0A0 + std::uint64_t unk0A8; // 0A8 + std::uint64_t unk0B0; // 0A8 + std::uint64_t unk0B8; // 0B8 + std::uint64_t unk0C0; // 0C0 + std::uint64_t unk0C8; // 0C8 + std::uint64_t unk0D0; // 0D0 + std::uint64_t unk0D8; // 0D8 + std::uint64_t unk0E0; // 0E0 + BSTArray unk0E8; // 0E8 + BGSSnapTemplate* parent; // 0F8 + BGSSnapBehavior* snapBehavior; // 100 + std::uint64_t unk108; // 108 + std::uint64_t unk110; // 110 + std::uint32_t unk118; // 118 + }; + static_assert(sizeof(BGSSnapTemplate) == 0x120); +} diff --git a/CommonLibSF/include/RE/B/BGSSoundKeywordMapping.h b/CommonLibSF/include/RE/B/BGSSoundKeywordMapping.h new file mode 100644 index 00000000..92e4c95a --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSoundKeywordMapping.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSSoundKeywordMapping : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSoundKeywordMapping); + SF_FORMTYPE(KSSM); + + ~BGSSoundKeywordMapping() override; // 00 + }; + //static_assert(sizeof(BGSSoundKeywordMapping) == 0xE0); +} diff --git a/CommonLibSF/include/RE/B/BGSSoundTagSet.h b/CommonLibSF/include/RE/B/BGSSoundTagSet.h new file mode 100644 index 00000000..962b0432 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSoundTagSet.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSSoundTagSet : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSoundTagSet); + SF_FORMTYPE(STAG); + + ~BGSSoundTagSet() override; // 00 + }; + //static_assert(sizeof(BGSSoundTagSet) == 0x88); +} diff --git a/CommonLibSF/include/RE/B/BGSSpeechChallengeObject.h b/CommonLibSF/include/RE/B/BGSSpeechChallengeObject.h new file mode 100644 index 00000000..343d9bdc --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSpeechChallengeObject.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESQuest; + + class BGSSpeechChallengeObject : + public TESForm, // 00 + public BGSKeywordForm // 30 + { + public: + SF_RTTI_VTABLE(BGSSpeechChallengeObject); + SF_FORMTYPE(SPCH); + + ~BGSSpeechChallengeObject() override; // 00 + + // members + BSTArray unk60; // 60 + TESQuest* quest; // 70 + std::uint32_t unk78; // 78 + std::uint32_t unk7C; // 7C + }; + static_assert(sizeof(BGSSpeechChallengeObject) == 0x80); +} diff --git a/CommonLibSF/include/RE/B/BGSStar.h b/CommonLibSF/include/RE/B/BGSStar.h new file mode 100644 index 00000000..6033ba7b --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSStar.h @@ -0,0 +1,34 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/T/TESForm.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSTimeOfDayData; + + namespace BSGalaxy + { + class BGSSunPresetForm; + + class BGSStar : + public TESForm, // 00 + public BGSKeywordForm // 30 + { + public: + SF_RTTI_VTABLE(BSGalaxy__BGSStar); + SF_FORMTYPE(STDT); + + ~BGSStar() override; // 00 + + // members + std::uint32_t uniqueID; // 60 + BGSStar* unk68; // 68 + BGSSunPresetForm* sunPreset; // 70 + BGSTimeOfDayData* timeOfDay; // 78 + BGSAudio::WwiseSoundHook unk80; // 80 + }; + static_assert(sizeof(BGSStar) == 0xB0); + } +} diff --git a/CommonLibSF/include/RE/B/BGSSunPresetForm.h b/CommonLibSF/include/RE/B/BGSSunPresetForm.h new file mode 100644 index 00000000..89926b4e --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSunPresetForm.h @@ -0,0 +1,41 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE::BSGalaxy +{ + class BGSSunPresetForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BSGalaxy__BGSSunPresetForm); + SF_FORMTYPE(SUNP); + + struct alignas(4) DawnDuskSettings + { + DirectX::XMFLOAT4 directionalColor; // 00 + float transitionStartAngle; // 10 + float transitionEndAngle; // 14 + }; + static_assert(sizeof(DawnDuskSettings) == 0x18); + + struct alignas(4) NightSettings + { + DirectX::XMFLOAT4 directionalColor; // 00 + float directionalIlluminance; // 10 + DirectX::XMFLOAT4 glareColor; // 14 + }; + static_assert(sizeof(NightSettings) == 0x24); + + ~BGSSunPresetForm() override; // 00 + + // members + BGSSunPresetForm* parent; // 30 + DirectX::XMFLOAT4 sunColor; // 38 + float sunIlluminance; // 48 + DirectX::XMFLOAT4 sunGlareColor; // 4C + DawnDuskSettings dawnDuskPreset; // 5C + NightSettings nightPreset; // 74 + std::uint64_t unk98; // 98 + }; + static_assert(sizeof(BGSSunPresetForm) == 0xA0); +} diff --git a/CommonLibSF/include/RE/B/BGSSurfaceBlock.h b/CommonLibSF/include/RE/B/BGSSurfaceBlock.h new file mode 100644 index 00000000..3af274a0 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSurfaceBlock.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE::BGSSurface +{ + class Block : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSurface__Block); + SF_FORMTYPE(SFBK); + + ~Block() override; // 00 + + // members + BSFixedString unk30; // 30 + std::uint64_t unk38; // 38 + std::uint64_t unk40; // 40 + std::uint32_t unk48; // 48 + std::uint32_t unk4C; // 4C + BSTArray unk50; // 50 + std::uint32_t unk60; // 60 + std::uint8_t unk64; // 64 + std::uint8_t unk65; // 65 + std::uint8_t unk66; // 66 + std::uint8_t unk67; // 67 + std::uint8_t unk68; // 68 + std::uint8_t unk69; // 69 + std::uint8_t unk6A; // 6A + }; + static_assert(sizeof(Block) == 0x70); +} diff --git a/CommonLibSF/include/RE/B/BGSSurfacePattern.h b/CommonLibSF/include/RE/B/BGSSurfacePattern.h new file mode 100644 index 00000000..916a5d64 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSurfacePattern.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE::BGSSurface +{ + class PatternStyle; + + class Pattern : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSurface__Pattern); + SF_FORMTYPE(SFPT); + + ~Pattern() override; // 00 + + // members + std::uint32_t unk30[256]; // 030 + std::uint64_t unk430; // 430 + std::uint64_t unk438; // 438 + PatternStyle* patternStyle; // 440 + std::uint32_t unk448[256]; // 448 + std::uint64_t unk848; // 848 + }; + static_assert(sizeof(Pattern) == 0x850); +} diff --git a/CommonLibSF/include/RE/B/BGSSurfacePatternStyle.h b/CommonLibSF/include/RE/B/BGSSurfacePatternStyle.h new file mode 100644 index 00000000..7347d1bd --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSurfacePatternStyle.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE::BGSSurface +{ + class PatternStyle : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSurface__PatternStyle); + SF_FORMTYPE(PTST); + + ~PatternStyle() override; // 00 + }; + static_assert(sizeof(PatternStyle) == 0x30); +} diff --git a/CommonLibSF/include/RE/B/BGSSurfaceTree.h b/CommonLibSF/include/RE/B/BGSSurfaceTree.h new file mode 100644 index 00000000..b2295dbb --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSSurfaceTree.h @@ -0,0 +1,25 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/T/TESForm.h" + +namespace RE::BGSSurface +{ + class Tree : public TESForm + { + public: + SF_RTTI_VTABLE(BGSSurface__Tree); + SF_FORMTYPE(SFTR); + + ~Tree() override; // 00 + + // members + std::uint64_t unk30; // 30 + std::uint64_t unk38; // 38 + std::uint64_t unk40; // 40 + std::uint64_t unk48; // 48 + std::uint64_t unk50; // 50 + BSTArray unk58; // 58 + }; + static_assert(sizeof(Tree) == 0x68); +} diff --git a/CommonLibSF/include/RE/B/BGSTimeOfDayData.h b/CommonLibSF/include/RE/B/BGSTimeOfDayData.h new file mode 100644 index 00000000..eb45d65d --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSTimeOfDayData.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSColorCurve.h" + +namespace RE +{ + class BGSTimeOfDayData : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSTimeOfDayData); + SF_FORMTYPE(TODD); + + ~BGSTimeOfDayData() override; // 00 + + // members + BSColorCurve colorAtTime; // 030 + BSFloatCurve luminanceAtTime; // 130 + float lightLuminanceMultiplier; // 170 + }; + static_assert(sizeof(BGSTimeOfDayData) == 0x178); +} diff --git a/CommonLibSF/include/RE/B/BGSTransform.h b/CommonLibSF/include/RE/B/BGSTransform.h new file mode 100644 index 00000000..5c330961 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSTransform.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/N/NiPoint3.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSTransform : public TESForm + { + public: + SF_RTTI_VTABLE(BGSTransform); + SF_FORMTYPE(TRNS); + + struct TransformData + { + public: + // members + NiPoint3 position; // 00 + NiPoint3 rotation; // 0C + float scale; // 18 + float minZoom; // 1C + float maxZoom; // 20 + }; + static_assert(sizeof(TransformData) == 0x24); + + ~BGSTransform() override; // 00 + + // members + TransformData data; // 30 + std::uint8_t unk54; // 54 + }; + static_assert(sizeof(BGSTransform) == 0x58); +} diff --git a/CommonLibSF/include/RE/B/BGSTraversal.h b/CommonLibSF/include/RE/B/BGSTraversal.h new file mode 100644 index 00000000..f7383091 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSTraversal.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSTraversal : public TESForm + { + public: + SF_RTTI_VTABLE(BGSTraversal); + SF_FORMTYPE(TRAV); + + ~BGSTraversal() override; // 00 + + // members + std::uint32_t unk30; // 30 + std::uint32_t unk34; // 34 + std::uint32_t unk38; // 38 + std::uint32_t unk3C; // 3C + std::int32_t unk40; // 40 + }; + static_assert(sizeof(BGSTraversal) == 0x48); +} diff --git a/CommonLibSF/include/RE/B/BGSVolumetricLighting.h b/CommonLibSF/include/RE/B/BGSVolumetricLighting.h new file mode 100644 index 00000000..b9656449 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSVolumetricLighting.h @@ -0,0 +1,96 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" + +namespace RE +{ + struct alignas(4) BGSVolumetricLightingSettings + { + public: + struct alignas(4) ExteriorAndInteriorSettings + { + float scatteringVolumeNear; // 00 + float scatteringVolumeFar; // 04 + float highFrequencyNoiseScale; // 08 + float highFrequencyNoiseDensityScale; // 0C + }; + static_assert(sizeof(ExteriorAndInteriorSettings) == 0x10); + + struct alignas(4) FogThicknessSettings + { + float thicknessNoiseScale; // 00 + float thicknessNoiseBias; // 04 + float minFogThickness; // 08 + float maxFogThickness; // 0C + }; + static_assert(sizeof(FogThicknessSettings) == 0x10); + + struct alignas(4) FogDensitySettings + { + float densityNoiseScale; // 00 + float densityNoiseBias; // 04 + float minFogDensity; // 08 + float maxFogDensity; // 0C + float densityStartDistance; // 10 + float densityFullDistance; // 14 + float densityDistanceExponent; // 18 + }; + static_assert(sizeof(FogDensitySettings) == 0x1C); + + struct alignas(4) HorizonFogSettings + { + float fogThickness; // 00 + float thicknessNoiseBias; // 04 + float minFogThickness; // 08 + float maxFogThickness; // 0C + }; + static_assert(sizeof(FogThicknessSettings) == 0x10); + + struct alignas(4) ExteriorSettings + { + FogThicknessSettings fogThickness; // 00 + FogDensitySettings fogDensity; // 10 + float unk2C; // 2C + float unk30; // 30 + float unk34; // 34 + float unk38; // 38 + float unk3C; // 3C + float unk40; // 40 + float unk44; // 44 + float unk48; // 48 + float unk4C; // 4C + float unk50; // 50 + float unk54; // 54 + float unk58; // 58 + float unk5C; // 5C + float unk60; // 60 + }; + static_assert(sizeof(ExteriorSettings) == 0x64); + + struct alignas(4) DistantLightingSettings + { + float scatteringTransition; // 00 + float scatteringFar; // 04 + }; + static_assert(sizeof(DistantLightingSettings) == 0x08); + + // members + ExteriorAndInteriorSettings exteriorAndInterior; // 00 + ExteriorSettings exterior; // 10 + DistantLightingSettings distantLighting; // 74 + }; + static_assert(sizeof(BGSVolumetricLightingSettings) == 0x7C); + + class BGSVolumetricLighting : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSVolumetricLighting); + SF_FORMTYPE(VOLI); + + ~BGSVolumetricLighting() override; // 00 + + // members + BGSVolumetricLightingSettings settings; // 30 + }; + static_assert(sizeof(BGSVolumetricLighting) == 0xB0); +} diff --git a/CommonLibSF/include/RE/B/BGSWeatherSettingsForm.h b/CommonLibSF/include/RE/B/BGSWeatherSettingsForm.h new file mode 100644 index 00000000..dfde1d64 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSWeatherSettingsForm.h @@ -0,0 +1,155 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/B/BSBlendable.h" +#include "RE/B/BSTArray.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSArtObject; + class BGSCloudForm; + class BGSConditionForm; + class BGSExplosion; + class BGSForceData; + class BGSLensFlare; + class BGSKeyword; + class BGSVolumetricLighting; + class SpellItem; + class TESImageSpace; + + class BGSWeatherSettingsForm : public BGSReflectedForm + { + public: + SF_RTTI_VTABLE(BGSWeatherSettingsForm); + SF_FORMTYPE(WTHS); + + struct WeatherChoiceSettings + { + std::uint32_t weight; // 00 + BSTArray subWeathers; // 08 + }; + static_assert(sizeof(WeatherChoiceSettings) == 0x18); + + struct alignas(4) ColorSettings + { + BSBlendable::ColorValue effectLighting; // 00 + BSBlendable::ColorValue fogFar; // 18 + BSBlendable::ColorValue fogFarHigh; // 30 + BSBlendable::ColorValue fogNear; // 48 + BSBlendable::ColorValue fogNearHigh; // 60 + BSBlendable::ColorValue sun; // 78 + BSBlendable::ColorValue sunGlare; // 90 + BSBlendable::ColorValue sunlight; // A8 + BSBlendable::ColorValue moonGlare; // C0 + BSBlendable::ColorValue moonlight; // D8 + }; + static_assert(sizeof(ColorSettings) == 0xF0); + + struct PrecipitationSettings + { + BSBlendable::FloatValue precipFadeIn; // 00 + BSBlendable::FloatValue precipFadeOut; // 0C + BSBlendable::FloatValue thunderFadeIn; // 18 + BSBlendable::FloatValue thunderFadeOut; // 24 + BSBlendable::ColorValue lightingColor; // 30 + BGSExplosion* lightingExplosion; // 48 + BSBlendable::FloatValue lightningDistanceMin; // 50 + BSBlendable::FloatValue lightningDistanceMax; // 5C + BSBlendable::FloatValue lightningFOV; // 68 + }; + static_assert(sizeof(PrecipitationSettings) == 0x78); + + struct MagicEffect + { + SpellItem* spell; // 00 + float threshold; // 08 + }; + static_assert(sizeof(MagicEffect) == 0x10); + + struct WeatherSound + { + enum class SoundType + { + kDefault = 0, + kPrecipitation, + kWind, + kThunder + }; + + BGSAudio::WwiseSoundHook soundHook; // 00 + stl::enumeration type; // 30 + float minDelay; // 34 + float maxDelay; // 38 + }; + static_assert(sizeof(WeatherSound) == 0x40); + + struct SoundEffectSettings + { + BGSArtObject* visualEffect; // 00 + BSBlendable::FloatValue beginVisualEffect; // 08 + BSBlendable::FloatValue endVisualEffect; // 14 + MagicEffect lightningStrikeEffect; // 20 + MagicEffect weatherActivateEffect; // 30 + std::vector sounds; // 40 + }; + static_assert(sizeof(SoundEffectSettings) == 0x58); + + struct SpellEffect + { + SpellItem* transitionSpell; // 00 + SpellItem* mainSpell; // 08 + BGSConditionForm* conditions; // 10 + }; + static_assert(sizeof(SpellEffect) == 0x18); + + struct SpellSettings + { + float transitionThreshold; // 00 + std::vector spellItems; // 08 + }; + static_assert(sizeof(SpellSettings) == 0x20); + + struct alignas(4) FoliageSettings + { + float windStrengthVariationSpeed; // 00 + float windStrengthVariationMin; // 04 + float windStrengthVariationMax; // 08 + float leafSecondaryMotionAmount; // 0C + float leafSecondaryMotionCutOff; // 10 + }; + static_assert(sizeof(FoliageSettings) == 0x14); + + ~BGSWeatherSettingsForm() override; // 00 + + // members + BGSWeatherSettingsForm* parent; // 030 + BGSKeyword* displayKeyword; // 038 + WeatherChoiceSettings weatherChoice; // 040 + TESImageSpace* imageSpace; // 058 + TESImageSpace* imageSpaceNight; // 060 + BGSVolumetricLighting* volumetricLighting; // 068 + BGSCloudForm* clouds; // 070 + ColorSettings color; // 078 + BGSArtObject* precipitationEffect; // 168 + PrecipitationSettings precipitation; // 170 + SoundEffectSettings soundEffects; // 1E8 + BGSArtObject* optionalPhotoModeEffect; // 240 + SpellSettings spellData; // 248 + BGSLensFlare* lensFlare; // 268 + float lensFlareCloudOcclusionStrength; // 270 + BGSForceData* windForce; // 278 + FoliageSettings foliage; // 280 + BSBlendable::FloatValue windDirectionRange; // 294 + BSBlendable::FloatValue windTurbulence; // 2A0 + bool windDirectionOverrideEnabled; // 2AC + BSBlendable::FloatValue windDirectionOverrideValue; // 2B0 + float transDelta; // 2BC + BSBlendable::FloatValue volatilityMultiplier; // 2C0 + BSBlendable::FloatValue visibilityMultiplier; // 2CC + BSTArray keywords; // 2D8 + std::uint64_t unk2E8; // 2E8 + std::uint64_t unk2F0; // 2F0 + }; + static_assert(sizeof(BGSWeatherSettingsForm) == 0x2F8); +} diff --git a/CommonLibSF/include/RE/B/BGSWwiseEventForm.h b/CommonLibSF/include/RE/B/BGSWwiseEventForm.h new file mode 100644 index 00000000..02e1c85b --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSWwiseEventForm.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/B/BGSConditionForm.h" +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" +#include "RE/W/WwiseGUID.h" + +namespace RE +{ + class TESQuest; + class TESPackage; + + class BGSWwiseEventForm : public TESForm + { + public: + SF_RTTI_VTABLE(BGSWwiseEventForm); + SF_FORMTYPE(WWED); + + ~BGSWwiseEventForm() override; // 00 + + // members + BGSEditorID formEditorID; // 30 + BGSAudio::WwiseGUID start; // 40 + BGSAudio::WwiseGUID end; // 50 + BGSConditionForm* conditions; // 60 + }; + static_assert(sizeof(BGSWwiseEventForm) == 0x68); +} diff --git a/CommonLibSF/include/RE/B/BGSWwiseKeywordMapping.h b/CommonLibSF/include/RE/B/BGSWwiseKeywordMapping.h new file mode 100644 index 00000000..ee529a50 --- /dev/null +++ b/CommonLibSF/include/RE/B/BGSWwiseKeywordMapping.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSKeyword; + + class BGSWwiseKeywordMapping : public TESForm + { + public: + SF_RTTI_VTABLE(BGSWwiseKeywordMapping); + SF_FORMTYPE(WKMF); + + ~BGSWwiseKeywordMapping() override; // 00 + + // members + std::vector keywords; // 30 + std::uint64_t unk48; // 48 + std::uint64_t unk50; // 50 + std::uint64_t unk58; // 58 + std::uint64_t unk60; // 60 + std::uint64_t unk68; // 68 + std::uint16_t unk70; // 70 + }; + static_assert(sizeof(BGSWwiseKeywordMapping) == 0x78); +} diff --git a/CommonLibSF/include/RE/B/BSBlendable.h b/CommonLibSF/include/RE/B/BSBlendable.h new file mode 100644 index 00000000..697df4fe --- /dev/null +++ b/CommonLibSF/include/RE/B/BSBlendable.h @@ -0,0 +1,32 @@ +#pragma once + +namespace RE::BSBlendable +{ + enum class BlendOp + { + kReplace = 0, + kAdd, + kMultiply, + kGreater + }; + + class alignas(4) ColorValue + { + public: + // members + stl::enumeration op; // 00 + DirectX::XMFLOAT4 value; // 04 + float blendAmount; // 14 + }; + static_assert(sizeof(ColorValue) == 0x18); + + class alignas(4) FloatValue + { + public: + // members + stl::enumeration op; // 0 + float value; // 4 + float blendValue; // 8 + }; + static_assert(sizeof(FloatValue) == 0xC); +} diff --git a/CommonLibSF/include/RE/B/BSColorCurve.h b/CommonLibSF/include/RE/B/BSColorCurve.h new file mode 100644 index 00000000..86bb2af4 --- /dev/null +++ b/CommonLibSF/include/RE/B/BSColorCurve.h @@ -0,0 +1,17 @@ +#pragma once + +#include "RE/B/BSFloatCurve.h" + +namespace RE +{ + class BSColorCurve + { + public: + // members + BSFloatCurve red; // 00 + BSFloatCurve green; // 40 + BSFloatCurve blue; // 80 + BSFloatCurve alpha; // C0 + }; + static_assert(sizeof(BSColorCurve) == 0x100); +} diff --git a/CommonLibSF/include/RE/B/BSFloat3DCurve.h b/CommonLibSF/include/RE/B/BSFloat3DCurve.h new file mode 100644 index 00000000..20ceec68 --- /dev/null +++ b/CommonLibSF/include/RE/B/BSFloat3DCurve.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/B/BSFloatCurve.h" + +namespace RE +{ + class BSFloat3DCurve + { + public: + // members + BSFloatCurve curveX; // 00 + BSFloatCurve curveY; // 40 + BSFloatCurve curveZ; // 80 + }; + static_assert(sizeof(BSFloat3DCurve) == 0xC0); +} diff --git a/CommonLibSF/include/RE/B/BSFloatCurve.h b/CommonLibSF/include/RE/B/BSFloatCurve.h new file mode 100644 index 00000000..3c2a7eb1 --- /dev/null +++ b/CommonLibSF/include/RE/B/BSFloatCurve.h @@ -0,0 +1,47 @@ +#pragma once + +namespace RE +{ + class BSFloatCurve + { + public: + enum class CurveType + { + kLinear = 0, + kQuadraticBezier, + kCubicBezier, + kQuadraticSpline, + kCubicSpline + }; + + enum class Edge + { + kClamp = 0, + kMirror, + kRepeat + }; + + struct alignas(4) Control + { + public: + // members + float input; // 00 + float value; // 04 + }; + static_assert(sizeof(Control) == 0x8); + + // members + std::uint64_t unk00; // 00 + std::vector controls; // 08 - std::vector> + float maxInput; // 20 + float minInput; // 24 + float inputDistance; // 28 + float maxValue; // 2C + float minValue; // 30 + float defaultValue; // 34 + stl::enumeration type; // 38 + stl::enumeration edge; // 39 + bool isSampleInterpolating; // 3A + }; + static_assert(sizeof(BSFloatCurve) == 0x40); +} diff --git a/CommonLibSF/include/RE/C/CollisionLayers.h b/CommonLibSF/include/RE/C/CollisionLayers.h new file mode 100644 index 00000000..72588aba --- /dev/null +++ b/CommonLibSF/include/RE/C/CollisionLayers.h @@ -0,0 +1,68 @@ +#pragma once + +namespace RE +{ + enum class COL_LAYER + { + kUnidentified = 0, + kStatic = 1, + kAnimStatic = 2, + kTransparent = 3, + kClutter = 4, + kWeapon = 5, + kProjectile = 6, + kSpell = 7, + kBiped = 8, + kTrees = 9, + kProps = 10, + kWater = 11, + kTrigger = 12, + kTerrain = 13, + kTrap = 14, + kNonCollidable = 15, + kCloudTrap = 16, + kGround = 17, + kPortal = 18, + kDebrisSmall = 19, + kDebrisLarge = 20, + kAcousticSpace = 21, + kActorZone = 22, + kProjectileZone = 23, + kGasTrap = 24, + kShellCasting = 25, + kTransparentWall = 26, + kInvisibleWall = 27, + kTransparentSmallAnim = 28, + kClutterLarge = 29, + kCharController = 30, + kStairHelper = 31, + kDeadBip = 32, + kBipedNoCC = 33, + kAvoidBox = 34, + kCollisionBox = 35, + kCameraSphere = 36, + kVolume = 37, + kConeProjectile = 38, + kCamera = 39, + kItemPicker = 40, + kLOS = 41, + kPathingPick = 42, + kShield = 43, + kFXCollider = 44, + kSpellExplosion = 45, + kDroppingPick = 46, + kDeadActorZone = 47, + kTriggerFallingTrap = 48, + kNavcut = 49, + kCritter = 50, + kSpellTrigger = 51, + kLivingAndDeadActors = 52, + kDetection = 53, + kTrapTrigger = 54, + kClutterNoCut = 55, + kCharBumper = 56, + kParticleCollider = 57, + kParticleOnly = 58, + kAudioOcclusion = 59 + }; +} diff --git a/CommonLibSF/include/RE/D/DecalData.h b/CommonLibSF/include/RE/D/DecalData.h new file mode 100644 index 00000000..7b5450d1 --- /dev/null +++ b/CommonLibSF/include/RE/D/DecalData.h @@ -0,0 +1,25 @@ +#pragma once + +namespace RE +{ + struct DECAL_DATA_DATA + { + public: + // members + float decalMinWidth; // 00 + float decalMaxWidth; // 04 + float decalMinHeight; // 08 + float decalMaxHeight; // 0C + float depth; // 10 + float shininess; // 14 + }; + static_assert(sizeof(DECAL_DATA_DATA) == 0x18); + + struct DecalData + { + public: + // members + DECAL_DATA_DATA data; // 00 + }; + static_assert(sizeof(DecalData) == 0x18); +} diff --git a/CommonLibSF/include/RE/E/EffectSetting.h b/CommonLibSF/include/RE/E/EffectSetting.h index 13be61c5..05a86827 100644 --- a/CommonLibSF/include/RE/E/EffectSetting.h +++ b/CommonLibSF/include/RE/E/EffectSetting.h @@ -19,7 +19,7 @@ namespace RE class BGSImpactDataSet; class BGSPerk; class BGSProjectile; - class EffectShader; + class TESEffectShader; class SpellItem; class TESImageSpaceModifier; class TESObjectLIGH; @@ -67,8 +67,8 @@ namespace RE ActorValueInfo* associatedSkill; // 08 BGSArtObject* castingArt; // 10 BGSDualCastData* dualCastData; // 18 - EffectShader* effectShader; // 20 - EffectShader* enchantShader; // 28 + TESEffectShader* effectShader; // 20 + TESEffectShader* enchantShader; // 28 BGSArtObject* enchantEffectArt; // 30 SpellItem* equipAbility; // 38 BGSExplosion* explosion; // 40 diff --git a/CommonLibSF/include/RE/H/Hazard.h b/CommonLibSF/include/RE/H/Hazard.h new file mode 100644 index 00000000..bd51a43e --- /dev/null +++ b/CommonLibSF/include/RE/H/Hazard.h @@ -0,0 +1,32 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/N/NiSmartPointer.h" +#include "RE/T/TESObjectREFR.h" + +namespace RE +{ + class Hazard : public TESObjectREFR + { + public: + SF_RTTI_VTABLE(Hazard); + SF_FORMTYPE(PHZD); + + ~Hazard() override; // 00 + + // members + BSTArray unkF0; // 0F0 - TESPointerHandles + mutable BSNonReentrantSpinLock lock; // 100 + void* unk108; // 108 - smart pointer + std::uint32_t ownerActor; // 110 - TESPointerHandle + std::uint32_t unk114; // 114 + void* unk118; // 118 - smart pointer + float age; // 120 + float lifetime; // 124 + float targetTimer; // 128 + float radius; // 12C + float magnitude; // 130 + std::uint32_t flags; // 134 + }; + static_assert(sizeof(Hazard) == 0x140); +} diff --git a/CommonLibSF/include/RE/T/TESClimate.h b/CommonLibSF/include/RE/T/TESClimate.h new file mode 100644 index 00000000..06e35f94 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESClimate.h @@ -0,0 +1,65 @@ +#pragma once + +#include "RE/B/BSTList.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSWeatherSettingsForm; + class TESWeather; + class TESGlobal; + + struct WeatherEntry + { + public: + // members + TESGlobal* chanceVar; // 00 + TESWeather* weather; // 08 + std::uint32_t chance; // 10 + }; + static_assert(sizeof(WeatherEntry) == 0x18); + + struct WeatherSettings + { + public: + // members + BGSWeatherSettingsForm* weatherSettings; // 00 + TESGlobal* chanceVar; // 08 + std::uint32_t chance; // 10 + }; + static_assert(sizeof(WeatherSettings) == 0x18); + + struct Timing + { + public: + struct Interval + { + public: + // members + std::uint8_t begin; // 0 + std::uint8_t end; // 1 + }; + static_assert(sizeof(Interval) == 0x2); + + // members + Interval sunrise; // 0 + Interval sunset; // 2 + std::uint8_t volatility; // 4 + }; + static_assert(sizeof(Timing) == 0x5); + + class TESClimate : public TESForm + { + public: + SF_RTTI_VTABLE(TESClimate); + SF_FORMTYPE(CLMT); + + ~TESClimate() override; // 00 + + // members + std::vector weatherTypes; // 30 + BSSimpleList weatherSettings; // 48 + Timing timing; // 58 + }; + static_assert(sizeof(TESClimate) == 0x60); +} diff --git a/CommonLibSF/include/RE/T/TESCombatStyle.h b/CommonLibSF/include/RE/T/TESCombatStyle.h new file mode 100644 index 00000000..b226e461 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESCombatStyle.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESCombatStyle : public TESForm + { + public: + SF_RTTI_VTABLE(TESCombatStyle); + SF_FORMTYPE(CSTY); + + ~TESCombatStyle() override; // 00 + }; + //static_assert(sizeof(TESCombatStyle) == 0x328); +} diff --git a/CommonLibSF/include/RE/T/TESEffectShader.h b/CommonLibSF/include/RE/T/TESEffectShader.h new file mode 100644 index 00000000..5d3f0964 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESEffectShader.h @@ -0,0 +1,51 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/T/TESModel.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSEffectSequenceForm; + + struct EffectShaderData // DATA + { + public: + // members + std::uint32_t unk00; // 00 + std::uint32_t unk04; // 04 + std::uint32_t unk08; // 08 + std::uint32_t unk0C; // 0C + std::uint32_t unk10; // 10 + std::uint32_t unk14; // 14 + std::uint32_t unk18; // 18 + std::uint32_t unk1C; // 1C + std::uint32_t unk20; // 20 + std::uint32_t unk24; // 24 + std::uint32_t unk28; // 28 + std::uint32_t unk2C; // 2C + std::uint32_t unk30; // 30 + std::uint32_t unk34; // 34 + BGSAudio::WwiseSoundHook ambientSound; // 38 + std::uint32_t unk68; // 68 + std::uint32_t unk6C; // 6C + }; + static_assert(sizeof(EffectShaderData) == 0x70); + + class TESEffectShader : + public TESForm, // 00 + public TESModel // 30 + { + public: + SF_RTTI_VTABLE(TESEffectShader); + SF_FORMTYPE(EFSH); + + ~TESEffectShader() override; // 00 + + // members + BGSEffectSequenceForm* effectSequence; // 50 + EffectShaderData data; // 58 + std::uint32_t unkC8; // C8 + }; + static_assert(sizeof(TESEffectShader) == 0xD0); +} diff --git a/CommonLibSF/include/RE/T/TESEyes.h b/CommonLibSF/include/RE/T/TESEyes.h new file mode 100644 index 00000000..c2b4f336 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESEyes.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" +#include "RE/T/TESTexture.h" + +namespace RE +{ + class TESEyes : + public TESForm, // 00 + public TESFullName, // 30 + public TESTexture // 40 + { + public: + SF_RTTI_VTABLE(TESEyes); + SF_FORMTYPE(EYES); + + ~TESEyes() override; // 00 + + // members + std::uint8_t unk50; // 50 + }; + static_assert(sizeof(TESEyes) == 0x58); +} diff --git a/CommonLibSF/include/RE/T/TESFaction.h b/CommonLibSF/include/RE/T/TESFaction.h new file mode 100644 index 00000000..8086335c --- /dev/null +++ b/CommonLibSF/include/RE/T/TESFaction.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" + +namespace RE +{ + class TESFaction : + public TESForm, // 000 + public TESFullName // 030 + { + public: + SF_RTTI_VTABLE(TESFaction); + SF_FORMTYPE(FACT); + + ~TESFaction() override; // 00 + }; + //static_assert(sizeof(TESFaction) == 0x158); +} diff --git a/CommonLibSF/include/RE/T/TESIdleForm.h b/CommonLibSF/include/RE/T/TESIdleForm.h new file mode 100644 index 00000000..0bd948ef --- /dev/null +++ b/CommonLibSF/include/RE/T/TESIdleForm.h @@ -0,0 +1,29 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESIdleForm : public TESForm + { + public: + SF_RTTI_VTABLE(TESIdleForm); + SF_FORMTYPE(IDLE); + + ~TESIdleForm() override; // 00 + + // members + BGSEditorID formEditorID; // 30 + TESCondition conditions; // 40 + TESForm* parentIdle; // 50 + TESIdleForm* prevIdle; // 58 + BSFixedString behaviorGraphName; // 60 + BSFixedString animEventName; // 68 + BSFixedString animFileName; // 70 + std::uint64_t unk78; // 78 + std::uint8_t unk80; // 80 + }; + static_assert(sizeof(TESIdleForm) == 0x88); +} diff --git a/CommonLibSF/include/RE/T/TESImageSpace.h b/CommonLibSF/include/RE/T/TESImageSpace.h new file mode 100644 index 00000000..c3be0c07 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESImageSpace.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BGSReflectedForm.h" +#include "RE/I/IAddressControllerStore.h" + +namespace RE +{ + class TESImageSpace : + public BGSReflectedForm, // 00 + public BSBind::IAddressControllerStore // 30 + { + public: + SF_RTTI_VTABLE(TESImageSpace); + SF_FORMTYPE(IMGS); + + ~TESImageSpace() override; // 00 + }; + // static_assert(sizeof(TESImageSpace) == 0x528); +} diff --git a/CommonLibSF/include/RE/T/TESLandTexture.h b/CommonLibSF/include/RE/T/TESLandTexture.h new file mode 100644 index 00000000..343fd961 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESLandTexture.h @@ -0,0 +1,36 @@ +#pragma once + +#include "RE/B/BGSEditorID.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSMaterialType; + + struct TEXTURE_HAVOK_DATA // HNAM + { + public: + // members + std::int8_t friction; // 0 + std::int8_t restitution; // 1 + }; + static_assert(sizeof(TEXTURE_HAVOK_DATA) == 0x2); + + class TESLandTexture : public TESForm + { + public: + SF_RTTI_VTABLE(TESLandTexture); + SF_FORMTYPE(LTEX); + + ~TESLandTexture() override; // 00 + + // members + BGSEditorID formEditorID; // 30 + BSFixedString materialPath; // 38 + TEXTURE_HAVOK_DATA havokData; // 48 + BGSMaterialType* materialType; // 50 + float unk58; // 58 + std::int32_t unk5C; // 5C + }; + static_assert(sizeof(TESLandTexture) == 0x60); +} diff --git a/CommonLibSF/include/RE/T/TESLoadScreen.h b/CommonLibSF/include/RE/T/TESLoadScreen.h new file mode 100644 index 00000000..28eb0aae --- /dev/null +++ b/CommonLibSF/include/RE/T/TESLoadScreen.h @@ -0,0 +1,39 @@ +#pragma once + +#include "RE/B/BGSLocalizedString.h" +#include "RE/T/TESCondition.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESModel.h" +#include "RE/T/TESTexture.h" + +namespace RE +{ + class BGSTransform; + class TESBoundObject; + + class TESLoadScreen : public TESForm + { + public: + SF_RTTI_VTABLE(TESLoadScreen); + SF_FORMTYPE(LSCR); + + struct LoadNIFData + { + TESModel model; // 00 + TESBoundObject* loadNif; // 20 + BGSTransform* transform; // 28 + std::uint64_t unk30; // 30 + std::uint64_t unk38; // 38 + }; + static_assert(sizeof(LoadNIFData) == 0x40); + + ~TESLoadScreen() override; // 00 + + // members + TESCondition conditions; // 30 + TESTexture loadscreen; // 40 - ICON + LoadNIFData* loadNIFData; // 50 + BGSLocalizedString loadingText; // 58 + }; + static_assert(sizeof(TESLoadScreen) == 0x60); +} diff --git a/CommonLibSF/include/RE/T/TESModelTri.h b/CommonLibSF/include/RE/T/TESModelTri.h new file mode 100644 index 00000000..07e77223 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESModelTri.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/T/TESModel.h" + +namespace RE +{ + class TESModelTri : public TESModel + { + public: + SF_RTTI_VTABLE(TESModelTri); + + ~TESModelTri() override; // 00 + + // override (TESModel) + const BSFixedString& GetFormComponentType() const override; // 01 - { return "TESModelTri_Component"; } + }; + static_assert(sizeof(TESModelTri) == 0x20); +} diff --git a/CommonLibSF/include/RE/T/TESPackage.h b/CommonLibSF/include/RE/T/TESPackage.h new file mode 100644 index 00000000..e50cbad6 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESPackage.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESPackage : public TESForm + { + public: + SF_RTTI_VTABLE(TESPackage); + SF_FORMTYPE(PACK); + + ~TESPackage() override; // 00 + }; + //static_assert(sizeof(TESPackage) == 0xE8); +} diff --git a/CommonLibSF/include/RE/T/TESRegion.h b/CommonLibSF/include/RE/T/TESRegion.h new file mode 100644 index 00000000..61fdcaa9 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESRegion.h @@ -0,0 +1,72 @@ +#pragma once + +#include "RE/B/BSTList.h" +#include "RE/N/NiPoint2.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class BGSLocation; + class TESRegionData; + class TESWorldSpace; + + struct TESRegionDataList + { + public: + // members + BSSimpleList regionDataList; // 00 + bool unk10; // 10 + }; + static_assert(sizeof(TESRegionDataList) == 0x18); + + class TESRegionPoint + { + public: + NiPoint2 point; // 00 + }; + static_assert(sizeof(TESRegionPoint) == 0x8); + + class TESRegionPointList : public BSSimpleList // RPLD + { + public: + struct ScaleResult + { + public: + TESRegionPoint point; // 00 + float dist; // 08 + float scale; // 0C + }; + static_assert(sizeof(ScaleResult) == 0x10); + + ScaleResult* lastScaleResult; // 10 + bool ownsPointMemory; // 18 + NiPoint2 minimums; // 1C + NiPoint2 maximums; // 24 + std::uint32_t distanceInsideAtMax; // 2C - RPLI + std::uint32_t count; // 30 + }; + static_assert(sizeof(TESRegionPointList) == 0x38); + + class TESRegion : public TESForm + { + public: + SF_RTTI_VTABLE(TESRegion); + SF_FORMTYPE(REGN); + + ~TESRegion() override; // 00 + + // add + virtual bool Validate(); // 62 + + // members + TESRegionDataList* dataList; // 30 + BSSimpleList* pointLists; // 38 + TESWorldSpace* worldSpace; // 40 + std::uint64_t unk48; // 48 + BGSLocation* location; // 50 + std::uint64_t unk58; // 58 + std::uint32_t unk60; // 60 + std::uint32_t unk64; // 64 + }; + static_assert(sizeof(TESRegion) == 0x68); +} diff --git a/CommonLibSF/include/RE/T/TESWaterForm.h b/CommonLibSF/include/RE/T/TESWaterForm.h new file mode 100644 index 00000000..0c0ce89c --- /dev/null +++ b/CommonLibSF/include/RE/T/TESWaterForm.h @@ -0,0 +1,110 @@ +#pragma once + +#include "RE/C/Color.h" +#include "RE/N/NiPoint3.h" +#include "RE/T/TESForm.h" +#include "RE/T/TESFullName.h" +#include "RE/W/WwiseSoundHook.h" + +namespace RE +{ + class BGSCurve3DForm; + class BGSMaterialType; + class MagicItem; + class SpellItem; + class TESImageSpace; + + struct WaterShaderData + { + public: + // members + float depthAmount; // 00 + Color shallowColor; // 04 + Color deepColor; // 08 + float shallowFogColorRange; // 0C + std::uint32_t unk10; // 10 + Color underwaterFogColor; // 14 + float underwaterFogAmount; // 18 + float underwaterFogDistNear; // 1C + float underwaterFogDistFar; // 20 + float normalMagnitude; // 24 + float normalFalloffShallow; // 28 + float normalFalloffDeep; // 2C + float reflectionAmount; // 30 + float fresnelAmount; // 34 + float surfaceEffectFalloff; // 38 + float displacementForce; // 3C + float displacementVelocity; // 40 + float windSpeedLayer2; // 44 + float windSpeedLayer3; // 48 + float displacementFalloff; // 4C + float displacementDampener; // 50 + float displacementSize; // 54 + Color reflectionColor; // 58 + float sunSpecularPower; // 5C + float sunSpecularMagnitude; // 60 + float sunSparklePower; // 64 + float sunSparkleMagnitude; // 68 + float lightRadius; // 6C + float lightBrightness; // 70 + float shininess; // 74 + float noiseWindDirections[3]; // 78 + float windSpeedLayer1; // 84 + float deepFogColorRange; // 88 + float shallowAlpha; // 8C + float deepAlpha; // 90 + float shallowFogAlphaRange; // 94 + }; + static_assert(sizeof(WaterShaderData) == 0x98); + + class TESWaterForm : + public TESForm, // 00 + public TESFullName // 30 + { + public: + SF_RTTI_VTABLE(TESWaterForm); + SF_FORMTYPE(WATR); + + ~TESWaterForm() override; // 00 + + // members + bool needUpdate; // 040 + float unk044; // 044 + float unk048; // 048 + float unk04C; // 04C + float unk050; // 05C + float unk054; // 054 + float unk058; // 058 + float unk05C; // 05C + float unk060; // 060 + float unk064; // 064 + float unk068; // 068 + float unk06C; // 06C + float unk070; // 070 + std::uint8_t alpha; // 074 + std::uint8_t flags; // 075 + BGSMaterialType* materialType; // 078 + BGSAudio::WwiseSoundHook sound; // 080 + WaterShaderData data; // 0B0 + std::uint32_t unk148; // 148 + std::uint32_t unk14C; // 14C + TESWaterForm* waterWeatherControl[3]; // 150 + MagicItem* consumeSpell; // 168 + SpellItem* contactSpell; // 170 + BGSCurve3DForm* riverAbsorptionCurve; // 178 + BGSCurve3DForm* oceanAbsorptionCurve; // 180 + BGSCurve3DForm* riverScatteringCurve; // 188 + BGSCurve3DForm* oceanScatteringCurve; // 190 + BGSCurve3DForm* phytoplanktonCurve; // 198 + BGSCurve3DForm* sedimentCurve; // 1A0 + BGSCurve3DForm* yellowMatterCurve; // 1A8 + void* unk1B0; // 1B0 - smart ptr + std::uint64_t unk1B8; // 1B8 + bool resetNoiseTextures; // 1C0 + TESImageSpace* imageSpace; // 1C8 + NiPoint3 linearVelocity; // 1D0 + NiPoint3 angularVelocity; // 1DC + }; + static_assert(sizeof(TESWaterForm) == 0x1E8); + static_assert(offsetof(TESWaterForm, data) == 0xB0); +} diff --git a/CommonLibSF/include/RE/T/TESWeather.h b/CommonLibSF/include/RE/T/TESWeather.h new file mode 100644 index 00000000..406e27f1 --- /dev/null +++ b/CommonLibSF/include/RE/T/TESWeather.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BGSKeywordForm.h" +#include "RE/T/TESForm.h" + +namespace RE +{ + class TESWeather : + public TESForm, // 00 + public BGSKeywordForm // 30 + { + public: + SF_RTTI_VTABLE(TESWeather); + SF_FORMTYPE(WTHR); + + ~TESWeather() override; // 00 + }; + //static_assert(sizeof(TESWeather) == 0xFC0); +} diff --git a/CommonLibSF/include/SFSE/Impl/WinAPI.h b/CommonLibSF/include/SFSE/Impl/WinAPI.h index a8179c86..d9468932 100644 --- a/CommonLibSF/include/SFSE/Impl/WinAPI.h +++ b/CommonLibSF/include/SFSE/Impl/WinAPI.h @@ -1403,6 +1403,45 @@ namespace SFSE::WinAPI namespace RE::DirectX { + struct XMCOLOR + { + public: + // members + union + { + struct + { + uint8_t b; + uint8_t g; + uint8_t r; + uint8_t a; + }; + uint32_t c; + }; + }; + static_assert(sizeof(XMCOLOR) == 0x4); + + struct XMFLOAT3 + { + public: + // members + float x; + float y; + float z; + }; + static_assert(sizeof(XMFLOAT3) == 0xC); + + struct XMFLOAT4 + { + public: + // members + float x; + float y; + float z; + float w; + }; + static_assert(sizeof(XMFLOAT4) == 0x10); + struct XMFLOAT4X4 { public: