diff --git a/include/RE/A/ACTOR_MOVEMENT_TYPE.h b/include/RE/A/ACTOR_MOVEMENT_TYPE.h new file mode 100644 index 00000000..d4926138 --- /dev/null +++ b/include/RE/A/ACTOR_MOVEMENT_TYPE.h @@ -0,0 +1,13 @@ +#pragma once + +namespace RE +{ + enum class ACTOR_MOVEMENT_TYPE : std::uint32_t + { + kWalk = 0x0, + kRun = 0x1, + kSneak = 0x2, + kBleedout = 0x3, + kSwim = 0x4 + }; +} diff --git a/include/RE/A/AIProcess.h b/include/RE/A/AIProcess.h index 9a40034c..f24f1fdc 100644 --- a/include/RE/A/AIProcess.h +++ b/include/RE/A/AIProcess.h @@ -35,6 +35,17 @@ namespace RE kOutDelete = 0x6 }; + enum class HEAD_TRACK_TYPE + { + kDefault = 0x0, + kAction = 0x1, + kCombat = 0x2, + kDialog = 0x3, + kScript = 0x4, + kProcedure = 0x5, + kTotal = 0x6 + }; + [[nodiscard]] TESAmmo* GetCurrentAmmo(BGSEquipIndex a_equipIndex) const { using func_t = decltype(&AIProcess::GetCurrentAmmo); diff --git a/include/RE/A/ActionOutput.h b/include/RE/A/ActionOutput.h new file mode 100644 index 00000000..dca810de --- /dev/null +++ b/include/RE/A/ActionOutput.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/B/BSFixedString.h" + +namespace RE +{ + class TESIdleForm; + + class ActionOutput + { + public: + static constexpr auto RTTI{ RTTI::ActionOutput }; + + enum class ACTION_RESULTS : std::uint32_t + { + kNotAllowed = 0xFFFFFFFF + }; + + // members + BSFixedString animEvent; // 00 + BSFixedString targetAnimEvent; // 08 + std::int32_t result; // 10 + TESIdleForm* sequence; // 18 + const TESIdleForm* animObjIdle; // 20 + std::uint32_t sequenceIndex; // 28; + }; + static_assert(sizeof(ActionOutput) == 0x30); +} diff --git a/include/RE/A/ActionPoints.h b/include/RE/A/ActionPoints.h new file mode 100644 index 00000000..1c282f30 --- /dev/null +++ b/include/RE/A/ActionPoints.h @@ -0,0 +1,27 @@ +#pragma once + +namespace RE +{ + class ActionPoints + { + public: + enum class Action + { + kUnarmed = 0x0, + kOneHandMelee = 0x1, + kTwoHandMelee = 0x2, + kMagic = 0x3, + kRanged = 0x4, + kReload = 0x5, + kSwitchWeapon = 0x6, + kToggleWeaponDrawn = 0x7, + kHeal = 0x8, + kPlayerVATSDeath = 0x9, + kPlayerDialogue = 0xA, + kSightedEnter = 0xB, + + kTotal = 0xC + }; + }; + static_assert(std::is_empty_v); +} diff --git a/include/RE/A/Actor.h b/include/RE/A/Actor.h index a46efed3..c7d8dd8e 100644 --- a/include/RE/A/Actor.h +++ b/include/RE/A/Actor.h @@ -124,16 +124,6 @@ namespace RE kUnderwater = 1 << 31, }; - enum class DETECTION_PRIORITY - { - kNone = 0x0, - kVeryLow = 0x1, - kLow = 0x2, - kNormal = 0x3, - kHigh = 0x4, - kCritical = 0x5, - }; - // add virtual void PlayPickUpSound(TESBoundObject* a_boundObj, bool a_pickUp, bool a_use); // 0C6 virtual float GetHeading() const { return data.angle.z; } // 0C7 diff --git a/include/RE/A/ActorEquipManager.h b/include/RE/A/ActorEquipManager.h index f21e8820..7d82f343 100644 --- a/include/RE/A/ActorEquipManager.h +++ b/include/RE/A/ActorEquipManager.h @@ -19,6 +19,18 @@ namespace RE public BSTEventSource // 08 { public: + enum class CanEquipResult + { + kSuccess = 0x0, + kInvalidItem = 0x1, + kNoModEquip = 0x2, + kPAWhileNotInPA = 0x3, + kNonPAWhileInPA = 0x4, + kEquipStateLocked = 0x5, + kItemBroken = 0x6, + kNoEquipKeyword = 0x7 + }; + [[nodiscard]] static ActorEquipManager* GetSingleton() { static REL::Relocation singleton{ ID::ActorEquipManager::Singleton }; diff --git a/include/RE/A/ActorMotionFeedbackData.h b/include/RE/A/ActorMotionFeedbackData.h new file mode 100644 index 00000000..e934521e --- /dev/null +++ b/include/RE/A/ActorMotionFeedbackData.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class ActorMotionFeedbackData + { + public: + // members + NiPoint3 desiredWorldDelta; // 00 + NiPoint3 actualWorldDelta; // 0C + float previousSpeed; // 18 + float previousDirection; // 1C + float currentHeading; // 20 + }; + static_assert(sizeof(ActorMotionFeedbackData) == 0x24); +} diff --git a/include/RE/A/ActorStance.h b/include/RE/A/ActorStance.h new file mode 100644 index 00000000..5e9d3043 --- /dev/null +++ b/include/RE/A/ActorStance.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + class ActorStance + { + public: + // members + std::uint8_t stance; // 00 + std::uint8_t stanceModifier; // 01 + bool mirrored; // 02 + }; + static_assert(sizeof(ActorStance) == 0x03); +} diff --git a/include/RE/A/ActorState.h b/include/RE/A/ActorState.h index 9fad0d2f..b7536f27 100644 --- a/include/RE/A/ActorState.h +++ b/include/RE/A/ActorState.h @@ -25,6 +25,7 @@ namespace RE virtual void SetReloadingImpl(bool a_reloading); // 26 [[nodiscard]] bool GetWeaponMagicDrawn() const noexcept { return weaponState >= WEAPON_STATE::kDrawn; } + [[nodiscard]] bool IsSwimming() const noexcept { return DoGetMoveModeBits(0x400); } // members std::uint32_t moveMode: 14; // 08:00 @@ -49,6 +50,9 @@ namespace RE INTERACTING_STATE interactingState: 2; // 0C:18 std::uint32_t headTrackRotation: 1; // 0C:20 std::uint32_t inSyncAnim: 1; // 0C:21 + + private: + bool DoGetMoveModeBits(std::uint16_t a_bits) const { return (a_bits & moveMode & 0x3FFF) == a_bits; } }; static_assert(sizeof(ActorState) == 0x10); } diff --git a/include/RE/A/AvoidAreaStruct.h b/include/RE/A/AvoidAreaStruct.h new file mode 100644 index 00000000..1ad95697 --- /dev/null +++ b/include/RE/A/AvoidAreaStruct.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BSPathingAvoidNode.h" + +namespace RE +{ + class TESObjectREFR; + + class AvoidAreaStruct + { + public: + // members + BSPathingAvoidNode avoideNode; // 00 + float timeExpire; // 24 + TESObjectREFR* refObj; // 28 + AvoidAreaStruct* next; // 30 + }; + static_assert(sizeof(AvoidAreaStruct) == 0x38); +} diff --git a/include/RE/B/BGSAssociationType.h b/include/RE/B/BGSAssociationType.h index ed71c3bf..1a73c948 100644 --- a/include/RE/B/BGSAssociationType.h +++ b/include/RE/B/BGSAssociationType.h @@ -13,9 +13,21 @@ namespace RE static constexpr auto VTABLE{ VTABLE::BGSAssociationType }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kASTP }; + enum class Member + { + kParent = 0x0, + kChild = 0x1, + kCount = 0x2 + }; + + enum class Flags + { + kFamily = 0x1 + }; + // members - BSFixedStringCS associationLabel[2][2]; // 20 - std::uint32_t flags; // 40 + BSFixedStringCS associationLabel[2][2]; // 20 + REX::EnumSet flags; // 40 }; static_assert(sizeof(BGSAssociationType) == 0x48); } diff --git a/include/RE/B/BGSAwakeSoundData.h b/include/RE/B/BGSAwakeSoundData.h new file mode 100644 index 00000000..239d17bd --- /dev/null +++ b/include/RE/B/BGSAwakeSoundData.h @@ -0,0 +1,25 @@ +#pragma once + +#include "RE/B/BSSoundHandle.h" + +namespace RE +{ + class BGSAwakeSoundData + { + public: + enum class State : std::uint32_t + { + kPlaying = 0x0, + kPaused = 0x1, + kStopped = 0x2, + + kTotal = 0x3 + }; + + BSSoundHandle sound; // 00 + std::uint32_t soundFormID; // 08 + float volume; // 0C + BGSAwakeSoundData::State state; // 10 + }; + static_assert(sizeof(BGSAwakeSoundData) == 0x14); +} diff --git a/include/RE/B/BGSCameraShot.h b/include/RE/B/BGSCameraShot.h index a34c1cce..a5409e57 100644 --- a/include/RE/B/BGSCameraShot.h +++ b/include/RE/B/BGSCameraShot.h @@ -44,6 +44,13 @@ namespace RE kDialogue = 0x2 }; + enum class CAM_ZOOM + { + kDefault = 0x0, + kDisable = 0x1, + kShotList = 0x2 + }; + class CAMERA_SHOT_DATA { public: diff --git a/include/RE/B/BGSCharacterMorph.h b/include/RE/B/BGSCharacterMorph.h index c8818b9a..ce8b7545 100644 --- a/include/RE/B/BGSCharacterMorph.h +++ b/include/RE/B/BGSCharacterMorph.h @@ -96,5 +96,34 @@ namespace RE std::uint16_t presetMaskID; // 38 }; static_assert(sizeof(Group) == 0x40); + + enum class WeightComponent : std::uint32_t + { + kThin = 0x0, + kMuscular = 0x1, + kFat = 0x2 + }; + + enum class BODY_MORPH_REGION : std::uint32_t + { + kHead = 0x0, + kUpperTorso = 0x1, + kArms = 0x2, + kLowerTorso = 0x3, + kLegs = 0x4 + }; + + enum class Axis : std::uint32_t + { + kPosX = 0x0, + kPosY = 0x1, + kPosZ = 0x2, + kRotX = 0x3, + kRotY = 0x4, + kRotZ = 0x5, + kScaleX = 0x6, + kScaleY = 0x7, + kScaleZ = 0x8 + }; } } diff --git a/include/RE/B/BGSConstructibleObject.h b/include/RE/B/BGSConstructibleObject.h index 7c13ccd9..4fba545c 100644 --- a/include/RE/B/BGSConstructibleObject.h +++ b/include/RE/B/BGSConstructibleObject.h @@ -33,6 +33,13 @@ namespace RE [[nodiscard]] TESForm* GetCreatedItem() const noexcept { return createdItem; } [[nodiscard]] std::uint16_t GetWorkshopPriority() const noexcept { return data.workshopPriority; } + bool PlayerPassesConditions() + { + using func_t = decltype(&BGSConstructibleObject::PlayerPassesConditions); + static REL::Relocation func{ ID::BGSConstructibleObject::PlayerPassesConditions }; + return func(this); + } + // members BSTArray>* requiredItems; // 50 TESCondition conditions; // 58 diff --git a/include/RE/B/BGSDecalEmitter.h b/include/RE/B/BGSDecalEmitter.h new file mode 100644 index 00000000..999568d2 --- /dev/null +++ b/include/RE/B/BGSDecalEmitter.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/N/NiPointer.h" + +namespace RE +{ + class BGSImpactData; + class BSTempEffectParticle; + + class BGSDecalEmitter + { + public: + // members + std::int32_t decalsToEmit; // 00 + bool finished; // 04 + BGSImpactData* decalImpactData; // 08 + NiPointer particleData; // 10 + }; + static_assert(sizeof(BGSDecalEmitter) == 0x18); +} diff --git a/include/RE/B/BGSDecalGroup.h b/include/RE/B/BGSDecalGroup.h new file mode 100644 index 00000000..d0843554 --- /dev/null +++ b/include/RE/B/BGSDecalGroup.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BSTArray.h" + +namespace RE +{ + class DECAL_CREATION_DATA; + + class BGSDecalGroup + { + public: + // members + bool permanentGroup; // 00 + bool manualSaveLoad; // 01 + BSTArray decalGroup; // 08 + BSTArray pendingDecals; // 20 + }; + static_assert(sizeof(BGSDecalGroup) == 0x38); +} diff --git a/include/RE/B/BGSDecalNode.h b/include/RE/B/BGSDecalNode.h new file mode 100644 index 00000000..2f61ee00 --- /dev/null +++ b/include/RE/B/BGSDecalNode.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/B/BSTArray.h" +#include "RE/N/NiNode.h" + +namespace RE +{ + class BSTempEffect; + + class __declspec(novtable) BGSDecalNode : + public NiNode // 00 + { + public: + static constexpr auto RTTI{ RTTI::BGSDecalNode }; + static constexpr auto VTABLE{ VTABLE::BGSDecalNode }; + static constexpr auto Ni_RTTI{ Ni_RTTI::BGSDecalNode }; + + // members + BSTArray> decals; // 140 + BSTArray decalCreationFrames; // 158 + bool skinnedNode; // 170 + }; + static_assert(sizeof(BGSDecalNode) == 0x180); +} diff --git a/include/RE/B/BGSDialogueBranch.h b/include/RE/B/BGSDialogueBranch.h index 4b0d6e39..a210bd88 100644 --- a/include/RE/B/BGSDialogueBranch.h +++ b/include/RE/B/BGSDialogueBranch.h @@ -14,6 +14,13 @@ namespace RE static constexpr auto VTABLE{ VTABLE::BGSDialogueBranch }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kDLBR }; + enum class Flag + { + kTopLevel = 0x0, + kBlocking = 0x1, + kExclusive = 0x2 + }; + // members std::uint32_t flags; // 20 TESQuest* quest; // 28 diff --git a/include/RE/B/BGSDirectionalAmbientLightingColors.h b/include/RE/B/BGSDirectionalAmbientLightingColors.h index d9a90e60..92bac6d3 100644 --- a/include/RE/B/BGSDirectionalAmbientLightingColors.h +++ b/include/RE/B/BGSDirectionalAmbientLightingColors.h @@ -5,6 +5,19 @@ namespace RE class BGSDirectionalAmbientLightingColors { public: + enum class ColorIndex : std::uint32_t + { + kXPos = 0x0, + kXNeg = 0x1, + kYPos = 0x2, + kYNeg = 0x3, + kZPos = 0x4, + kZNeg = 0x5, + kAxisCount = 0x6, + kSpecularTint = 0x6, + kColorCount = 0x7 + }; + // members std::uint32_t colorValues[7]; // 00 float fresnelPower; // 1C diff --git a/include/RE/B/BGSExplosion.h b/include/RE/B/BGSExplosion.h index 8704c559..c189666e 100644 --- a/include/RE/B/BGSExplosion.h +++ b/include/RE/B/BGSExplosion.h @@ -23,6 +23,20 @@ namespace RE static constexpr auto VTABLE{ VTABLE::BGSExplosion }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kEXPL }; + enum class EXPLOSION_TYPE + { + kNormal = 0x0, + kChain = 0x1 + }; + + enum class KnockDownMode + { + kNever = 0x0, + kAlways = 0x1, + kFormula = 0x2, + kNPC = 0x3 + }; + // members BGSExplosionData data; // 0D8 }; diff --git a/include/RE/B/BGSHeadPart.h b/include/RE/B/BGSHeadPart.h index 04e8c906..0299d249 100644 --- a/include/RE/B/BGSHeadPart.h +++ b/include/RE/B/BGSHeadPart.h @@ -45,6 +45,13 @@ namespace RE kHeadRear = 0x9 }; + enum class MorphIndex + { + kRaceMorph = 0x0, + kDefaultMorph = 0x1, + kChargenMorph = 0x2 + }; + [[nodiscard]] bool IsExtraPart() const noexcept { return flags.all(Flag::kExtraPart); } // members diff --git a/include/RE/B/BGSLOSData.h b/include/RE/B/BGSLOSData.h new file mode 100644 index 00000000..753521b1 --- /dev/null +++ b/include/RE/B/BGSLOSData.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/N/NiRefObject.h" + +namespace RE +{ + class __declspec(novtable) BGSLOSData : + public NiRefObject // 00 + { + public: + static constexpr auto RTTI{ RTTI::BGSLOSData }; + static constexpr auto VTABLE{ VTABLE::BGSLOSData }; + + // members + std::uint8_t* losData; // 10 + std::uint16_t* quadGridOffsetArray; // 18 + std::uint32_t losDataSize; // 20 + std::uint16_t indexCount; // 24 + }; + static_assert(sizeof(BGSLOSData) == 0x28); +} diff --git a/include/RE/B/BGSLocAlias.h b/include/RE/B/BGSLocAlias.h new file mode 100644 index 00000000..190afa35 --- /dev/null +++ b/include/RE/B/BGSLocAlias.h @@ -0,0 +1,31 @@ +#pragma once + +#include "RE/B/BGSBaseAlias.h" + +namespace RE +{ + class BGSKeyword; + class BGSLocation; + class TESCondition; + class TESQuest; + + class __declspec(novtable) BGSLocAlias : + public BGSBaseAlias // 00 + { + public: + static constexpr auto RTTI{ RTTI::BGSLocAlias }; + static constexpr auto VTABLE{ VTABLE::BGSLocAlias }; + + // members + BGSLocation* forcedLoc; // 28 + BGSKeyword* forcedFromAliasFilter; // 30 + TESQuest* externalQuest; // 38 + TESCondition* conditions; // 40 + std::uint32_t forcedFromAlias; // 48 + std::uint32_t forcedFromEvent; // 4C + std::uint32_t forcedEventData; // 50 + std::uint32_t externalAlias; // 54 + std::uint32_t closestToAlias; // 58 + }; + static_assert(sizeof(BGSLocAlias) == 0x60); +} diff --git a/include/RE/B/BGSMessage.h b/include/RE/B/BGSMessage.h index b6d2e1b8..4a325859 100644 --- a/include/RE/B/BGSMessage.h +++ b/include/RE/B/BGSMessage.h @@ -21,6 +21,12 @@ namespace RE static constexpr auto VTABLE{ VTABLE::BGSMessage }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kMESG }; + enum class MessageFlag + { + kMessageBox = 0x0, + kInitialDelay = 0x1 + }; + void AddButton(MESSAGEBOX_BUTTON* btn) { using func_t = decltype(&BGSMessage::AddButton); diff --git a/include/RE/B/BGSProjectile.h b/include/RE/B/BGSProjectile.h index 5cf3c62c..235073fd 100644 --- a/include/RE/B/BGSProjectile.h +++ b/include/RE/B/BGSProjectile.h @@ -23,6 +23,33 @@ namespace RE static constexpr auto VTABLE{ VTABLE::BGSProjectile }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kPROJ }; + enum class BGSProjectileFlags + { + kHitscan = 0x1, + kExplosion = 0x2, + kExplosionAltTrigger = 0x4, + kMuzzleFlash = 0x8, + kBounceOnImpact = 0x10, + kCanTurnOff = 0x20, + kCanPickup = 0x40, + kSupersonic = 0x80, + kPinsLimbs = 0x100, + kPassSMTransparent = 0x200, + kDisableCombatAimCorrection = 0x400, + kPenetratesGeometry = 0x800, + kContinuousUpdate = 0x1000, + kSeeksTarget = 0x2000, + kFirstMotionBit = 0x10, + kMotionMissile = 0x10000, + kMotionGrenade = 0x20000, + kMotionBeam = 0x40000, + kMotionFlamethrower = 0x80000, + kMotionCone = 0x100000, + kMotionBarrier = 0x200000, + kMotionArrow = 0x400000, + kMotionTypes = 0x7F0000 + }; + bool CollidesWithSmallTransparentLayer() { using func_t = decltype(&BGSProjectile::CollidesWithSmallTransparentLayer); diff --git a/include/RE/B/BGSQuestObjective.h b/include/RE/B/BGSQuestObjective.h new file mode 100644 index 00000000..092e49e5 --- /dev/null +++ b/include/RE/B/BGSQuestObjective.h @@ -0,0 +1,24 @@ +#pragma once + +#include "RE/B/BGSLocalizedString.h" + +namespace RE +{ + class TESQuest; + class TESQuestTarget; + + class BGSQuestObjective + { + public: + // members + BGSLocalizedString displayText; // 00 + TESQuest* ownerQuest; // 08 + TESQuestTarget** targets; // 10 + std::uint32_t numTargets; // 18 + std::uint16_t index; // 1C + bool initialized; // 1E + char state; // 1F + std::uint32_t flags; // 20 + }; + static_assert(sizeof(BGSQuestObjective) == 0x28); +} diff --git a/include/RE/B/BGSStoryEvent.h b/include/RE/B/BGSStoryEvent.h new file mode 100644 index 00000000..90c62ed1 --- /dev/null +++ b/include/RE/B/BGSStoryEvent.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + class BGSStoryEvent + { + public: + // members + std::uint32_t id; // 00 + std::uint32_t index; // 04 + std::uint64_t memberArray[6]; // 08 + }; + static_assert(sizeof(BGSStoryEvent) == 0x38); +} diff --git a/include/RE/B/BGSTerminal.h b/include/RE/B/BGSTerminal.h index 34ca0662..dc5e6817 100644 --- a/include/RE/B/BGSTerminal.h +++ b/include/RE/B/BGSTerminal.h @@ -30,6 +30,16 @@ namespace RE class MenuItem { public: + enum class Flag + { + kBackToTop = 0x0, + kRedraw = 0x1, + kSubmenu = 0x2, + kText = 0x3, + kImage = 0x4, + kHolotape = 0x5 + }; + union USelectionResult { BGSTerminal* subMenu; @@ -40,12 +50,12 @@ namespace RE static_assert(sizeof(USelectionResult) == 0x8); // members - BGSLocalizedString itemText; // 00 - BGSLocalizedString responseText; // 08 - USelectionResult selectionResult; // 10 - TESCondition conditions; // 18 - std::uint16_t id; // 20 - std::int8_t flags; // 22 + BGSLocalizedString itemText; // 00 + BGSLocalizedString responseText; // 08 + USelectionResult selectionResult; // 10 + TESCondition conditions; // 18 + std::uint16_t id; // 20 + REX::EnumSet flags; // 22 }; static_assert(sizeof(MenuItem) == 0x28); diff --git a/include/RE/B/BSExternalAudioIO.h b/include/RE/B/BSExternalAudioIO.h new file mode 100644 index 00000000..bb7c2982 --- /dev/null +++ b/include/RE/B/BSExternalAudioIO.h @@ -0,0 +1,45 @@ +#pragma once + +#include "RE/B/BSIntrusiveRefCounted.h" +#include "RE/B/BSResource.h" + +namespace RE +{ + namespace BSExternalAudioIO + { + class ExternalLoad : + public BSIntrusiveRefCounted // 00 + { + public: + // members + std::uint32_t bufferSize; // 04 + std::uint32_t sourceSize; // 08 + std::uint32_t streamOffset; // 0C + void* buffer; // 10 + }; + static_assert(sizeof(ExternalLoad) == 0x18); + + class __declspec(novtable) ExternalIOInterface + { + public: + static constexpr auto RTTI{ RTTI::BSExternalAudioIO__ExternalIOInterface }; + static constexpr auto VTABLE{ VTABLE::BSExternalAudioIO__ExternalIOInterface }; + + virtual ~ExternalIOInterface(); // 00 + + // add + virtual BSResource::ErrorCode Request(const BSResource::ID*, BSExternalAudioIO::ExternalLoad**); // 01 + }; + static_assert(sizeof(ExternalIOInterface) == 0x08); + + class LipVoiceHeader + { + public: + // members + std::uint32_t magic; // 00 + std::uint32_t version; // 04 + std::uint32_t lipSize; // 08 + }; + static_assert(sizeof(LipVoiceHeader) == 0x0C); + } +} diff --git a/include/RE/B/BSGraphics.h b/include/RE/B/BSGraphics.h index 13f20f96..e2959e7f 100644 --- a/include/RE/B/BSGraphics.h +++ b/include/RE/B/BSGraphics.h @@ -690,6 +690,24 @@ namespace RE }; static_assert(sizeof(CubeMapRenderTargetProperties) == 0x24); + class DynamicTriShapeData + { + public: + // members + VertexBuffer* vb; // 00 + std::uint32_t dataStride; // 08 + }; + static_assert(sizeof(DynamicTriShapeData) == 0x10); + + class DynamicTriShapeDrawData + { + public: + // members + REX::W32::ID3D11Buffer* buffer; // 00 + std::uint32_t offset; // 08 + }; + static_assert(sizeof(DynamicTriShapeDrawData) == 0x10); + class RenderTargetManager { public: @@ -735,6 +753,15 @@ namespace RE }; static_assert(sizeof(RenderTargetManager) == 0xFF0); + class OcclusionQuery + { + public: + // members + REX::W32::ID3D11Query* occlusionQuery; // 00 + std::uint32_t inUse; // 08 + }; + static_assert(sizeof(OcclusionQuery) == 0x10); + namespace Utility { inline void ConvertHALFToNiPoint3Stream(const std::uint16_t* a_src, NiPoint3* a_dst, std::uint32_t a_count, std::uint32_t a_stride) diff --git a/include/RE/B/BSIMusicTrack.h b/include/RE/B/BSIMusicTrack.h index 1e23104c..8a92d273 100644 --- a/include/RE/B/BSIMusicTrack.h +++ b/include/RE/B/BSIMusicTrack.h @@ -8,7 +8,14 @@ namespace RE static constexpr auto RTTI{ RTTI::BSIMusicTrack }; static constexpr auto VTABLE{ VTABLE::BSIMusicTrack }; - enum class MUSIC_STATUS; + enum class MUSIC_STATUS + { + kInactive = 0x0, + kPlaying = 0x1, + kPaused = 0x2, + kFinishing = 0x3, + kFinished = 0x4 + }; virtual ~BSIMusicTrack() = default; // 00 diff --git a/include/RE/B/BSLensFlareSpriteData.h b/include/RE/B/BSLensFlareSpriteData.h new file mode 100644 index 00000000..dfd76c9b --- /dev/null +++ b/include/RE/B/BSLensFlareSpriteData.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class BSLensFlareSpriteData + { + public: + enum class Flags + { + kRotates = 0x1, + kShrinks = 0x2 + }; + + // members + NiColor color; // 00 + float width; // 0C + float height; // 10 + float position; // 14 + float angularFade; // 18 + float opacity; // 1C; + REX::EnumSet flags; // 20 + }; + static_assert(sizeof(BSLensFlareSpriteData) == 0x24); +} diff --git a/include/RE/B/BSLog.h b/include/RE/B/BSLog.h new file mode 100644 index 00000000..09febca6 --- /dev/null +++ b/include/RE/B/BSLog.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/B/BSFixedString.h" +#include "RE/B/BSSpinLock.h" +#include "RE/B/BSSystemFile.h" + +namespace RE +{ + class BSLog + { + public: + // members + BSFixedString logName; // 00 + BSFixedString logPath; // 08 + bool addTimestamps; // 10 + std::uint32_t logsToKeep; // 14 + BSSpinLock bufferLock; // 18 + char* buffer; // 20 + const std::uint32_t bufferSize; // 28 + char* writePos; // 30 + char* readPos; // 38 + bool folderExists; // 40 + bool fileOpen; // 41 + BSSystemFile log; + }; + static_assert(sizeof(BSLog) == 0x58); +} diff --git a/include/RE/B/BSNavmeshObstacleCoverData.h b/include/RE/B/BSNavmeshObstacleCoverData.h new file mode 100644 index 00000000..9a015df6 --- /dev/null +++ b/include/RE/B/BSNavmeshObstacleCoverData.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/B/BSNavmeshCoverEdge.h" +#include "RE/B/BSTArray.h" +#include "RE/N/NiRefObject.h" + +namespace RE +{ + class __declspec(novtable) BSNavmeshObstacleCoverData : + public NiRefObject // 00 + { + public: + static constexpr auto RTTI{ RTTI::BSNavmeshObstacleCoverData }; + static constexpr auto VTABLE{ VTABLE::BSNavmeshObstacleCoverData }; + + // members + BSTArray coverEdgeArray; // 10 + std::uint32_t flags; // 28 + }; + static_assert(sizeof(BSNavmeshObstacleCoverData) == 0x30); +} diff --git a/include/RE/B/BSNavmeshTriHandle.h b/include/RE/B/BSNavmeshTriHandle.h new file mode 100644 index 00000000..3eef57d7 --- /dev/null +++ b/include/RE/B/BSNavmeshTriHandle.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + class BSNavmeshInfo; + + class BSNavmeshTriHandle + { + public: + BSNavmeshInfo* pNavMeshInfo; // 00 + std::uint16_t triangle; // 08 + }; + static_assert(sizeof(BSNavmeshTriHandle) == 0x10); +} diff --git a/include/RE/B/BSNavmeshTriLocation.h b/include/RE/B/BSNavmeshTriLocation.h new file mode 100644 index 00000000..8d2bcd18 --- /dev/null +++ b/include/RE/B/BSNavmeshTriLocation.h @@ -0,0 +1,15 @@ +#pragma once + +#include "RE/B/BSNavmeshTriHandle.h" +#include "RE/N/NiPoint.h" + +namespace RE +{ + class BSNavmeshTriLocation : + public BSNavmeshTriHandle // 00 + { + // members + NiPoint3 location; // 10 + }; + static_assert(sizeof(BSNavmeshTriLocation) == 0x20); +} diff --git a/include/RE/B/BSPathingAvoidNode.h b/include/RE/B/BSPathingAvoidNode.h new file mode 100644 index 00000000..3ce970f2 --- /dev/null +++ b/include/RE/B/BSPathingAvoidNode.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class BSPathingAvoidNode + { + public: + enum class AVOID_NODE_TYPE : std::uint32_t + { + kSphere = 0x0, + kCylinder = 0x1, + kSphereActor = 0x2, + kSphereTarget = 0x3, + kSphereThreat = 0x4, + kSphereObstacle = 0x5 + }; + + // members + NiPoint3 point1; // 00 + NiPoint3 point2; // 0C + float radius; // 18 + float cost; // 1C + BSPathingAvoidNode::AVOID_NODE_TYPE type; // 20 + }; + static_assert(sizeof(BSPathingAvoidNode) == 0x24); +} diff --git a/include/RE/B/BSPathingFaceTarget.h b/include/RE/B/BSPathingFaceTarget.h new file mode 100644 index 00000000..1b7b40be --- /dev/null +++ b/include/RE/B/BSPathingFaceTarget.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class BSPathingFaceTarget + { + public: + enum class FACE_TARGET_TYPE : std::uint32_t + { + kNone = 0x0, + kAngle = 0x1, + kPoint = 0x2, + kPointHeading = 0x3 + }; + + // members + BSPathingFaceTarget::FACE_TARGET_TYPE type; // 00 + NiPoint3 point; // 04 + float angle; // 10 + float angleTolernaceCCW; // 14 + float angleToleranceCW; // 18 + }; + static_assert(sizeof(BSPathingFaceTarget) == 0x1C); +} diff --git a/include/RE/B/BSPathingGoal.h b/include/RE/B/BSPathingGoal.h new file mode 100644 index 00000000..f84368f2 --- /dev/null +++ b/include/RE/B/BSPathingGoal.h @@ -0,0 +1,35 @@ +#pragma once + +#include "RE/B/BSPathingLocation.h" +#include "RE/N/NiPoint.h" + +namespace RE +{ + class BSPathingGoal + { + public: + enum class GOAL_RADIUS_TYPE + { + kNone = 0x0, + kSoft = 0x1, + kHard = 0x2, + kMask = 0x3 + }; + + enum class GOAL_HEIGHT_TYPE + { + kNone = 0x0, + kFixed = 0x10, + kMask = 0x10 + }; + + // members + NiPoint3 targetPoint; // 00 + float targetAngleTolerance; // 0C + BSPathingLocation location; // 10 + float zDelta; // 40 + float goalRadius; // 44 + float normalizedSpeedAtGoal; // 48 + }; + static_assert(sizeof(BSPathingGoal) == 0x50); +} diff --git a/include/RE/B/BSPathingLocation.h b/include/RE/B/BSPathingLocation.h index f2d2fd00..f48d8d90 100644 --- a/include/RE/B/BSPathingLocation.h +++ b/include/RE/B/BSPathingLocation.h @@ -7,7 +7,6 @@ namespace RE { class BSNavmeshInfo; - class BSPatchingCell; class BSPathingLocation { diff --git a/include/RE/B/BSPathingStart.h b/include/RE/B/BSPathingStart.h new file mode 100644 index 00000000..76fb8c66 --- /dev/null +++ b/include/RE/B/BSPathingStart.h @@ -0,0 +1,29 @@ +#pragma once + +#include "RE/B/BSPathingLocation.h" + +namespace RE +{ + class BSPathingStart + { + public: + enum class START_TANGENT_TYPE + { + kNone = 0x0, + kSet = 0x1, + kKeep = 0x2, + kMask = 0x3 + }; + + enum class FLAGS + { + kSelected = 0x0, + kStartsMoving = 0x1 + }; + + // members + BSPathingLocation location; // 00 + float tangent; // 30 + }; + static_assert(sizeof(BSPathingStart) == 0x38); +} diff --git a/include/RE/B/BSRandom.h b/include/RE/B/BSRandom.h index b418ad9b..a58b115d 100644 --- a/include/RE/B/BSRandom.h +++ b/include/RE/B/BSRandom.h @@ -24,5 +24,12 @@ namespace RE static REL::Relocation func{ ID::BSRandom::Float0To1 }; return func(); } + + inline std::int32_t Int(std::int32_t a_min, std::int32_t a_max) + { + using func_t = decltype(&BSRandom::Int); + static REL::Relocation func{ ID::BSRandom::Int }; + return func(a_min, a_max); + } } } diff --git a/include/RE/B/BSShaderAccumulator.h b/include/RE/B/BSShaderAccumulator.h new file mode 100644 index 00000000..758aa6c4 --- /dev/null +++ b/include/RE/B/BSShaderAccumulator.h @@ -0,0 +1,54 @@ +#pragma once + +#include "RE/B/BSBatchRenderer.h" +#include "RE/B/BSShaderManager.h" +#include "RE/N/NiAlphaAccumulator.h" +#include "RE/N/NiColor.h" +#include "RE/N/NiPoint.h" +#include "RE/N/NiPointer.h" +#include "RE/S/SunOcclusionTest.h" + +namespace RE +{ + class BSLight; + class ShadowSceneNode; + + class __declspec(novtable) BSShaderAccumulator : + public NiAlphaAccumulator // 000 + { + public: + static constexpr auto RTTI{ RTTI::BSShaderAccumulator }; + static constexpr auto VTABLE{ VTABLE::BSShaderAccumulator }; + static constexpr auto Ni_RTTI{ Ni_RTTI::BSShaderAccumulator }; + + enum class WATER_SIDE : std::uint32_t + { + kAboveWater = 0x0, + kBelowWater = 0x1 + }; + + // add + virtual void FinishAccumulatingPreResolveDepth(); // 2E + virtual void FinishAccumulatingPostResolveDepth(); // 2F + + // members + std::uint32_t sunPixelCount; // 058 + bool waitingForSunQuery; // 05C + float percentSunOccludedStored; // 060 + SunOcclusionTest sunTests[3]; // 068 + bool firstPerson; // 0B0 + bool zPrePass; // 0B1 + NiColorA silhouetteColor; // 0B4 + bool renderDecals; // 0C4 + BSBatchRenderer batchRenderer; // 0C8 + std::uint32_t currentPass; // 548 + std::uint32_t currentBucket; // 54C + bool currentActiveA; // 550 + ShadowSceneNode* activeShadowSceneNode; // 558 + BSShaderManager::etRenderMode renderMode; // 560 + NiPointer shadowLight; // 568 + NiPoint3A eyePosition; // 570 + std::uint32_t depthPassIndex; // 580 + }; + static_assert(sizeof(BSShaderAccumulator) == 0x590); +} diff --git a/include/RE/B/BSShaderManager.h b/include/RE/B/BSShaderManager.h new file mode 100644 index 00000000..b6ccf975 --- /dev/null +++ b/include/RE/B/BSShaderManager.h @@ -0,0 +1,193 @@ +#pragma once + +#include "RE/B/BSGeometry.h" +#include "RE/N/NiColor.h" +#include "RE/N/NiPoint.h" +#include "RE/N/NiPointer.h" +#include "RE/N/NiTexture.h" +#include "RE/N/NiTransform.h" + +namespace RE +{ + class ShadowSceneNode; + + class BSShaderManager + { + public: + enum class BSShaderTimerMode : std::uint32_t + { + kDefault = 0x0, + kDelta = 0x1, + kSystem = 0x2, + kRealDelta = 0x3, + kFrameCount = 0x4, + kAccumulatedDelta = 0x5, + + kTotal = 0x6 + }; + + enum class ShaderEnum : std::uint32_t + { + kEffect = 0x0, + kUtility = 0x1, + kDistantTree = 0x2, + kParticle = 0x3, + kDFPrepass = 0x4, + kDFLight = 0x5, + kDFComposite = 0x6, + kSky = 0x7, + kLighting = 0x8, + kBloodSpatter = 0x9, + kWater = 0xA, + kFaceCustomization = 0xB, + kImageSpace = 0xC, + + kTotal = 0xD + }; + + enum class eCameraInWaterState : std::uint32_t + { + kAboveWater = 0x0, + kPartiallyAboveWater = 0x1, + kPartiallyUnderWater = 0x2, + kUnderWater = 0x3 + }; + + enum class eSceneGraphEnum : std::uint32_t + { + kWorld = 0x0, + kUIOld = 0x1, + kPreview = 0x2, + kUILoadingMenu = 0x3, + kUI = 0x4, + + kTotal = 0x5 + }; + + enum class etRenderFlag : std::uint32_t + { + kColorWriteDisable = 0x0 + }; + + enum class etRenderMode : std::uint32_t + { + kNormal = 0x0, + kNumLights = 0x1, + kNumNonShadowLights = 0x2, + kNumShadowLights = 0x3, + kNumPasses = 0x4, + kSinglePass = 0x5, + kTexUsage = 0x6, + kDegrade = 0x7, + kFade = 0x8, + kShadowSplitDebug = 0x9, + kTexSize = 0xA, + kFadeNodeTriDebug = 0xB, + kOverdraw = 0xC, + kDepthPrepass = 0xD, + kOcclusionMap = 0xE, + kShadowmap = 0xF, + kShadowmapDir = 0x10, + kShadowmapPB = 0x11, + kLocalmap = 0x12, + kFrozen = 0x13, + kScreenSplatter = 0x14, + kLODOnlyNoNoise = 0x15, + kSilhouetteLOD = 0x16, + kSilhouette = 0x17, + kDeferredGBuffer = 0x18, + kDeferredGB0 = 0x19, + kDeferredGBDebgStart = 0x19, + kDeferredGB1 = 0x1A, + kDeferredGB2 = 0x1B, + kDeferredGB3 = 0x1C, + kDeferredGB4 = 0x1D, + kDeferredGB5 = 0x1E, + kDeferredGBDebugEnd = 0x1E, + kDeferredGBAll = 0x1F, + kLightvis = 0x20, + kVATSMask = 0x21, + kVATSMaskDebug = 0x22, + kVATSMaskPrepass = 0x23, + kMapMaker = 0x25, + kSimpleLighting = 0x26, + + kTotal = 0x27 + }; + + enum class etShadowMode : std::uint32_t + { + kISFilter = 0x0, + kPCF4 = 0x1, + kPCF9 = 0x2, + kLoopFilter = 0x3 + }; + + class State + { + // members + ShadowSceneNode* shadowSceneNode[5]; // 00 + float timerValues[6]; // 28 + std::uint32_t frameCount; // 40 + NiColorA loadedRange; // 44 + bool interior; // 54 + bool liteBrite; // 55 + bool deferredRGBEmit; // 56 + bool deferredRGBSpec; // 57 + bool menuScreenPremultAlpha; // 58 + bool menuScreenPostAA; // 59 + float menuScreenAlpha; // 5C + bool characterLightEnabled; // 60 + bool screenSpaceReflectionsEnabled; // 61 + bool screenSpaceSubsurfaceScatteringEnabled; // 62 + std::uint32_t pipboyScreenTarget; // 64 + NiPointer pipboyFXTexture; // 68 + float pipboyScreenEmitIntensity; // 70 + float pipboyScreenDiffuseIntensity; // 74 + float pipboyScreenEmitIntensityWA; // 78 + float pipboyScreenDiffuseIntensityWA; // 7C + float specularLODStartFadeSquared; // 80 + float specularLODEndSquared; // 84 + float landLOFaceSeconds; // 88 + float leafAnimDampenDistStartSPU; // 8C + float leafAnimDampenDistEndSPU; // 90 + NiPoint2 oldGridArrayCenter; // 94 + NiPoint2 gridArrayCenter; // 9C + float gridArrayLerpStart; // A4 + bool LODFadeInProgress; // A8 + std::uint8_t sceneGraph; // A9 + BSShaderManager::etRenderMode debugMode; // AC + std::uint32_t debugColorWrite; // B0 + NiTransform directionalAmbientTransform; // C0 + NiTransform localDirectionalAmbientTransform; // 100 + NiColorA ambientSpecular; // 140 + bool ambientSpecularEnabled; // 150 + std::uint32_t textureTransformCurrentBuffer; // 154 + std::uint32_t textureTransformFlipMode; // 158 + std::uint32_t cameraInWaterState; // 15C + float cameraNear; // 160 + float cameraFar; // 164 + float waterIntersect; // 168 + NiColorA menuScreenBlendParams; // 16C + NiColorA debugTintColor; // 17C + float boneTintingTiming; // 18C + NiPoint3 forwardLightOffset; // 190 + NiPoint3 clipVolume[2]; // 19C + NiPointer clipVolumeGeom; // 1B8 + NiColorA maskRectParams; // 1C0 + NiColorA UIMaskRectsA[16]; // 1D0 + NiColorA UIMaskRectColorsA[16]; // 2D0 + NiColorA characterLightParams; // 3D0 + std::uint32_t forceDisableFrame; // 3E0 + bool effectShaderVATSHighlight; // 3E4 + bool forceEffectShaderPremultAlpha; // 3E5 + bool forceDisableSSR; // 3E6 + bool forceDisableGodrays; // 3E7 + bool forceDisableDirLights; // 3E8 + bool pendingForceDisableSSR; // 3E9 + bool pendingForceDisableGodrays; // 3EA + bool pendingForceDisableDirLights; // 3EB + }; + static_assert(sizeof(State) == 0x3F0); + }; +} diff --git a/include/RE/B/BSSoundHandle.h b/include/RE/B/BSSoundHandle.h index f0242ff4..626724c0 100644 --- a/include/RE/B/BSSoundHandle.h +++ b/include/RE/B/BSSoundHandle.h @@ -2,11 +2,29 @@ namespace RE { + class BSISoundOutputModel; + class BSSoundHandle { public: ~BSSoundHandle() noexcept {} // NOLINT(modernize-use-equals-default) + enum class ASSUMED_STATE : std::uint32_t + { + kInitialized = 0x0, + kPlaying = 0x1, + kStopped = 0x2, + kPaused = 0x3 + }; + + enum class LOOP_TYPE : std::uint32_t + { + kNone = 0x0, + kWholeFile = 0x1, + kEnvFast = 0x2, + kEnvSlow = 0x3 + }; + bool FadeInPlay(std::uint16_t a_milliseconds) { using func_t = decltype(&BSSoundHandle::FadeInPlay); @@ -21,6 +39,34 @@ namespace RE return func(this, a_milliseconds); } + bool IsPlaying() const + { + using func_t = decltype(&BSSoundHandle::IsPlaying); + static REL::Relocation func{ ID::BSSoundHandle::IsPlaying }; + return func(this); + } + + bool Play() + { + using func_t = decltype(&BSSoundHandle::Play); + static REL::Relocation func{ ID::BSSoundHandle::Play }; + return func(this); + } + + bool SetOutputModel(const BSISoundOutputModel* a_outputModel) + { + using func_t = decltype(&BSSoundHandle::SetOutputModel); + static REL::Relocation func{ ID::BSSoundHandle::SetOutputModel }; + return func(this, a_outputModel); + } + + bool Stop() + { + using func_t = decltype(&BSSoundHandle::Stop); + static REL::Relocation func{ ID::BSSoundHandle::Stop }; + return func(this); + } + // members std::uint32_t soundID; // 0 bool assumeSuccess; // 4 diff --git a/include/RE/B/BSTempEffectWeaponBlood.h b/include/RE/B/BSTempEffectWeaponBlood.h index 20b7e7ad..be64384f 100644 --- a/include/RE/B/BSTempEffectWeaponBlood.h +++ b/include/RE/B/BSTempEffectWeaponBlood.h @@ -5,6 +5,8 @@ namespace RE { + class NiAVObject; + class __declspec(novtable) BSTempEffectWeaponBlood : public BSTempEffect // 00 { @@ -16,6 +18,13 @@ namespace RE ~BSTempEffectWeaponBlood() override; + static void ClearEffectForWeapon(NiAVObject* a_weapon3D) + { + using func_t = decltype(&BSTempEffectWeaponBlood::ClearEffectForWeapon); + REL::Relocation func{ ID::BSTempEffectWeaponBlood::ClearEffectForWeapon }; + return func(a_weapon3D); + } + // members NiPointer weapon; // 30 float fBloodAmount; // 38 diff --git a/include/RE/B/BSUtilities.h b/include/RE/B/BSUtilities.h index 7414b617..1821ff03 100644 --- a/include/RE/B/BSUtilities.h +++ b/include/RE/B/BSUtilities.h @@ -4,29 +4,37 @@ namespace RE { + class BSFlattenedBoneTree; class NiAVObject; namespace BSUtilities { inline std::uint16_t ConvertFloatToHalf(float a_value) { - using func_t = decltype(&ConvertFloatToHalf); + using func_t = decltype(&BSUtilities::ConvertFloatToHalf); static REL::Relocation func{ ID::BSUtilities::ConvertFloatToHalf }; return func(a_value); } inline float ConvertHalfToFloat(std::uint16_t a_value) { - using func_t = decltype(&ConvertHalfToFloat); + using func_t = decltype(&BSUtilities::ConvertHalfToFloat); static REL::Relocation func{ ID::BSUtilities::ConvertHalfToFloat }; return func(a_value); } inline NiAVObject* GetObjectByName(NiAVObject* a_root, const BSFixedString& a_name, bool a_tryInternal, bool a_dontAttach) { - using func_t = decltype(&GetObjectByName); + using func_t = decltype(&BSUtilities::GetObjectByName); static REL::Relocation func{ ID::BSUtilities::GetObjectByName }; return func(a_root, a_name, a_tryInternal, a_dontAttach); } + + inline BSFlattenedBoneTree* GetFlattenedBoneTree(NiAVObject* a_root) + { + using func_t = decltype(&BSUtilities::GetFlattenedBoneTree); + static REL::Relocation func{ ID::BSUtilities::GetFlattenedBoneTree }; + return func(a_root); + } } } diff --git a/include/RE/B/BaseTreeData.h b/include/RE/B/BaseTreeData.h new file mode 100644 index 00000000..cd6616cf --- /dev/null +++ b/include/RE/B/BaseTreeData.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/B/BSIntrusiveRefCounted.h" +#include "RE/B/BoneData.h" +#include "RE/N/NiMatrix3.h" + +namespace RE +{ + class BaseTreeData : + public BSIntrusiveRefCounted // 00 + { + public: + // members + BSTArray branchBoneData; // 08 + BSTArray parentWorldBoneRotations; // 20 + }; + static_assert(sizeof(BaseTreeData) == 0x38); +} diff --git a/include/RE/B/BoneData.h b/include/RE/B/BoneData.h new file mode 100644 index 00000000..2b721a08 --- /dev/null +++ b/include/RE/B/BoneData.h @@ -0,0 +1,17 @@ +#pragma once + +#include "RE/N/NiMatrix3.h" +#include "RE/N/NiPoint.h" + +namespace RE +{ + class BoneData + { + public: + // members + NiMatrix3 localBoneRotation; // 00 + NiPoint3 worldBoneDir; // 30 + std::uint32_t parentWorldBoneRotationIndex; // 3C + }; + static_assert(sizeof(BoneData) == 0x40); +} diff --git a/include/RE/B/bhkCharacterController.h b/include/RE/B/bhkCharacterController.h index ecd8988a..ebb63bd6 100644 --- a/include/RE/B/bhkCharacterController.h +++ b/include/RE/B/bhkCharacterController.h @@ -43,6 +43,18 @@ namespace RE kSizing = 0x2 }; + class CheckGoodType + { + public: + // members + bool checkDangerous; // 00 + bool checkActors; // 01 + bool checkGround; // 02 + bool checkEnvironment; // 03 + bool useHitToleranceCheck; // 04 + }; + static_assert(sizeof(CheckGoodType) == 0x05); + // add virtual float GetKeepDistanceImpl() const = 0; // 31 virtual void InitPhysicsSystemImpl(const bhkCharacterControllerCinfo& a_info) = 0; // 32 diff --git a/include/RE/C/CHARACTER_FLAGS.h b/include/RE/C/CHARACTER_FLAGS.h new file mode 100644 index 00000000..d9ccf450 --- /dev/null +++ b/include/RE/C/CHARACTER_FLAGS.h @@ -0,0 +1,39 @@ +#pragma once + +namespace RE +{ + enum class CHARACTER_FLAGS : std::uint32_t + { + kQuadruped = 0x1, + kNoGravityOnGround = 0x2, + kTryStep = 0x4, + kNoFriction = 0x8, + kStuckQuad = 0x20, + kAllowJumpNoContact = 0x10, + kAnimAngleMod = 0x40, + kHitDamage = 0x80, + kSupport = 0x100, + kHasPotentialSupportManifold = 0x200, + kCanJump = 0x400, + kChaseBip = 0x800, + kFollowRagdoll = 0x1000, + kJumping = 0x2000, + kNotPushable = 0x4000, + kCheckSupport = 0x10000, + kNoSim = 0x20000, + kFarAway = 0x40000, + kOnStilts = 0x80000, + kQuickSimulate = 0x100000, + kRecordHits = 0x200000, + kComputeTiltPreIntegrate = 0x400000, + kShouldersUnderWater = 0x800000, + kOnStairs = 0x1000000, + kCanPitch = 0x2000000, + kCanRoll = 0x4000000, + kNoCharacterCollisions = 0x8000000, + kNotPushablePermanent = 0x10000000, + kPossiblePathObstacle = 0x20000000, + kShapeRequiresZRot = 0x40000000, + kSwimAtWaterSurface = 0x80000000 + }; +} diff --git a/include/RE/C/COMMAND_REFUSAL_TYPE.h b/include/RE/C/COMMAND_REFUSAL_TYPE.h new file mode 100644 index 00000000..f27e0b94 --- /dev/null +++ b/include/RE/C/COMMAND_REFUSAL_TYPE.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + enum class COMMAND_REFUSAL_TYPE + { + kNone = 0x0, + kAny = 0x1, + kImpossible = 0x2, + kMoral = 0x3, + + kTotal = 0x4 + }; +} diff --git a/include/RE/C/COVER_TYPE.h b/include/RE/C/COVER_TYPE.h new file mode 100644 index 00000000..29e01464 --- /dev/null +++ b/include/RE/C/COVER_TYPE.h @@ -0,0 +1,23 @@ +#pragma once + +namespace RE +{ + enum class COVER_TYPE : std::uint32_t + { + kNone = 0x0, + kLedge = 0x1, + kCrouch = 0x2, + kPartial = 0x2, + kVeryLow = 0x4, + kNarrow = 0x3, + kLow = 0x4, + kFull = 0x4, + kMid = 0x5, + kHigh = 0x6, + kTypeCount = 0x7, + kTypeMask = 0xFFFFFF, + kDirectionLeft = 0x40000000, + kDirectionRight = 0x80000000, + kDirectionMask = 0xC0000000 + }; +} diff --git a/include/RE/C/CombatBehaviorStack.h b/include/RE/C/CombatBehaviorStack.h new file mode 100644 index 00000000..f025847e --- /dev/null +++ b/include/RE/C/CombatBehaviorStack.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + class CombatBehaviorStack + { + public: + // members + std::uint8_t* buffer; // 00 + std::uint32_t bufferSize; // 08 + std::uint32_t size; // 0C + }; + static_assert(sizeof(CombatBehaviorStack) == 0x10); +} diff --git a/include/RE/C/CombatRange.h b/include/RE/C/CombatRange.h new file mode 100644 index 00000000..ab9f8547 --- /dev/null +++ b/include/RE/C/CombatRange.h @@ -0,0 +1,11 @@ +#pragma once + +namespace RE +{ + class CombatRange + { + float minRange; // 00 + float maxRange; // 04 + }; + static_assert(sizeof(CombatRange) == 0x8); +} diff --git a/include/RE/C/CombatUtilities.h b/include/RE/C/CombatUtilities.h index ebba9369..4fcb46de 100644 --- a/include/RE/C/CombatUtilities.h +++ b/include/RE/C/CombatUtilities.h @@ -38,11 +38,25 @@ namespace RE float a_heading, NiPoint3& a_trajectoryPos) { - using func_t = decltype(&CalculateProjectileTrajectory); + using func_t = decltype(&CombatUtilities::CalculateProjectileTrajectory); static REL::Relocation func{ ID::CombatUtilities::CalculateProjectileTrajectory }; return func(a_projectilePos, a_projectileVelocity, a_projectileGravity, a_targetPos, a_heading, a_trajectoryPos); } inline static REL::Relocation fWorldGravity{ ID::CombatUtilities::WorldGravity }; + + inline bool IsActorUsingMelee(Actor* a_actor) + { + using func_t = decltype(CombatUtilities::IsActorUsingMelee); + static REL::Relocation func{ ID::CombatUtilities::IsActorUsingMelee }; + return func(a_actor); + } + + inline bool IsActorUsingUnarmed(Actor* a_actor) + { + using func_t = decltype(CombatUtilities::IsActorUsingUnarmed); + static REL::Relocation func{ ID::CombatUtilities::IsActorUsingUnarmed }; + return func(a_actor); + } } } diff --git a/include/RE/C/CountdownTimer.h b/include/RE/C/CountdownTimer.h new file mode 100644 index 00000000..4a8e3998 --- /dev/null +++ b/include/RE/C/CountdownTimer.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + class CountdownTimer + { + public: + // members + std::uint64_t startTime; // 00 + std::uint64_t endTime; // 08 + bool isActive; // 10 + }; + static_assert(sizeof(CountdownTimer) == 0x18); +} diff --git a/include/RE/D/DECAL_CREATION_DATA.h b/include/RE/D/DECAL_CREATION_DATA.h new file mode 100644 index 00000000..439ca0c2 --- /dev/null +++ b/include/RE/D/DECAL_CREATION_DATA.h @@ -0,0 +1,59 @@ +#pragma once + +#include "RE/B/BSPointerHandle.h" +#include "RE/N/NiColor.h" +#include "RE/N/NiMatrix3.h" +#include "RE/N/NiPoint.h" +#include "RE/N/NiPointer.h" + +namespace RE +{ + class BGSTextureSet; + class NiAVObject; + class NiNode; + class TESObjectCELL; + + class DECAL_CREATION_DATA + { + public: + // members + NiMatrix3 projection; // 00 + NiPoint3A origin; // 30 + NiPoint3A direction; // 40 + NiPoint3A surfaceNormal; // 50 + ObjectRefHandle objRef; // 60 + NiPointer avObj; // 68 + NiNode* clone; // 70 + BGSTextureSet* texSet; // 78 + BGSTextureSet* texSet2; // 80 + std::int32_t index; // 88 + float decalWidth; // 8C + float decalHeight; // 90 + float decalDepth; // 94 + TESObjectCELL* parentCell; // 98 + float parallaxOcclusionScale; // A0 + NiNode* skinnedDecalNode; // A8 + float specular; // B0 + float decalEpsilon; // B4 + float placementRadius; // 0B8 + NiColor vertexColor; // BC + std::uint32_t bodyParts; // C8 + std::uint8_t subTex; // CC + bool permanent; // CD + bool parallaxOcclusionShadows; // CE + bool alphaTesting; // CF + bool alphaBlending; // D0 + bool multiplicativeBlending; // D1 + std::uint8_t parallaxOcclusionMaxPasses; // D2 + bool modelSpace; // D3 + bool forceFade; // D4 + bool twoSided; // D5 + bool preprocessed; // D6 + bool manualSaveLoad; // D7 + std::uint32_t sceneGraphIndex; // D8 + float decalLifetime; // DC + bool dynamic; // E0 + bool useGbufferNormal; // E1 + }; + static_assert(sizeof(DECAL_CREATION_DATA) == 0xF0); +} diff --git a/include/RE/D/DETECTION_PRIORITY.h b/include/RE/D/DETECTION_PRIORITY.h new file mode 100644 index 00000000..c8b7f9b6 --- /dev/null +++ b/include/RE/D/DETECTION_PRIORITY.h @@ -0,0 +1,14 @@ +#pragma once + +namespace RE +{ + enum class DETECTION_PRIORITY + { + kNone = 0x0, + kVeryLow = 0x1, + kLow = 0x2, + kNormal = 0x3, + kHigh = 0x4, + kCritical = 0x5, + }; +} diff --git a/include/RE/D/DeferredHideLimb.h b/include/RE/D/DeferredHideLimb.h new file mode 100644 index 00000000..cf2a4abf --- /dev/null +++ b/include/RE/D/DeferredHideLimb.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BGSBodyPartDefs.h" +#include "RE/N/NiPointer.h" + +namespace RE +{ + class NiNode; + + class DeferredHideLimb + { + public: + // members + float dismemberTimer; // 00 + REX::EnumSet limbIndex; // 04 + NiPointer dismemberedLimbRoot; // 08 + NiPointer replacementLimb; // 10 + DeferredHideLimb* next; // 18 + bool explosion; // 20 + }; + static_assert(sizeof(DeferredHideLimb) == 0x28); +} diff --git a/include/RE/D/DesiredMovementData.h b/include/RE/D/DesiredMovementData.h new file mode 100644 index 00000000..7ceb7cc5 --- /dev/null +++ b/include/RE/D/DesiredMovementData.h @@ -0,0 +1,17 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class DesiredMovementData + { + public: + // members + NiPoint3A position; // 00 + NiPoint3A orientation; // 10 + NiPoint3A movementSpeed; // 20 + NiPoint3A rotationSpeed; // 30 + }; + static_assert(sizeof(DesiredMovementData) == 0x40); +} diff --git a/include/RE/D/DetectionLevels.h b/include/RE/D/DetectionLevels.h new file mode 100644 index 00000000..0b0070ea --- /dev/null +++ b/include/RE/D/DetectionLevels.h @@ -0,0 +1,13 @@ +#pragma once + +namespace RE +{ + class DetectionLevels + { + public: + // members + std::int16_t visualLevel; // 00 + std::int16_t soundLevel; // 02 + }; + static_assert(sizeof(DetectionLevels) == 0x04); +} diff --git a/include/RE/D/DialogueItem.h b/include/RE/D/DialogueItem.h new file mode 100644 index 00000000..7bb19dbf --- /dev/null +++ b/include/RE/D/DialogueItem.h @@ -0,0 +1,35 @@ +#pragma once + +#include "RE/B/BSTArray.h" + +namespace RE +{ + class DialogueResponse; + class TESObjectREFR; + class TESQuest; + class TESTopic; + class TESTopicInfo; + + class DialogueItem + { + public: + ~DialogueItem(); + + DialogueResponse* GetCurrentResponse() + { + return currentResponse < responses.size() ? responses[currentResponse] : nullptr; + } + + // members + BSTArray responses{}; // 00 + TESTopicInfo* info{}; // 18 + TESTopic* topic{}; // 20 + TESQuest* quest{}; // 28 + TESObjectREFR* speaker{}; // 30 + std::uint32_t currentResponse{ static_cast(-1) }; // 38 + bool endResponse{ false }; // 3C + bool canSkip{ false }; // 3D + bool subtitle{ false }; // 3E + }; + static_assert(sizeof(DialogueItem) == 0x40); +} diff --git a/include/RE/D/DialogueResponse.h b/include/RE/D/DialogueResponse.h new file mode 100644 index 00000000..4f303050 --- /dev/null +++ b/include/RE/D/DialogueResponse.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/B/BSFixedString.h" + +namespace RE +{ + class BGSKeyword; + class BGSSoundDescriptorForm; + class TESIdleForm; + + class DialogueResponse + { + public: + // members + BSFixedStringCS text; // 00 + BGSKeyword* animFaceArchType; // 08 + std::uint16_t percent; // 10 + BSFixedString voice; // 18 + TESIdleForm* speakerIdle; // 20 + TESIdleForm* listenIdle; // 28 + BGSSoundDescriptorForm* voiceSound; // 30 + bool useEmotion; // 38 + bool soundLip; // 39 + bool endOnSceneEnd; // 3A + }; + static_assert(sizeof(DialogueResponse) == 0x40); +} diff --git a/include/RE/E/EXTRA_DATA_TYPE.h b/include/RE/E/EXTRA_DATA_TYPE.h index b85da7f8..c3f6f4e8 100644 --- a/include/RE/E/EXTRA_DATA_TYPE.h +++ b/include/RE/E/EXTRA_DATA_TYPE.h @@ -110,7 +110,7 @@ namespace RE kPrimitive, // kOpenCloseActivateRef, // kAnimNoteReceiver, // - kAmmo, // + kAmmo, // ExtraAmmo kPatrolRefData, // kPackageData, // kOcclusionShape, // diff --git a/include/RE/E/Explosion.h b/include/RE/E/Explosion.h index 325a9f95..43495f97 100644 --- a/include/RE/E/Explosion.h +++ b/include/RE/E/Explosion.h @@ -7,6 +7,7 @@ #include "RE/B/BSSoundHandle.h" #include "RE/B/BSTArray.h" #include "RE/B/BSTSmartPointer.h" +#include "RE/H/hknpClosestUniqueBodyIdHitCollector.h" #include "RE/N/NiPoint.h" #include "RE/N/NiPointer.h" #include "RE/T/TESObjectREFR.h" @@ -74,32 +75,31 @@ namespace RE virtual void FindTargets(); // C8 // members - // hknpClosestUniqueBodyIdHitCollector collector; // 110 - std::byte collector[0x520 - 0x110]; // 110 - void* explosionDBHandle; // 520 - TODO - float age; // 528 - float obj3Dlifetime; // 52C - float audioLifetime; // 530 - float buildTime; // 534 - float innerRadius; // 538 - float outerRadius; // 53C - float imageSpaceRadius; // 540 - float damageMult; // 544 - BSSimpleList targetList; // 548 - BSTSmallArray soundHandles; // 558 - NiPointer light; // 588 - ObjectRefHandle owner; // 590 - ObjectRefHandle explodedRef; // 594 - ObjectRefHandle createdRef; // 598 - BSTSmartPointer actorCause; // 5A0 - NonActorMagicCaster* caster; // 5A8 - BGSObjectInstanceT weaponSource; // 5B0 - std::int32_t frameCount; // 5C0 - NiPoint3A closestPoint; // 5D0 - NiPoint3A closestPointNormal; // 5E0 - float calculatedDamage; // 5F0 - float scale; // 5F4 - REX::EnumSet flags; // 5F8 + hknpClosestUniqueBodyIdHitCollector collector; // 110 + void* explosionDBHandle; // 520 - TODO + float age; // 528 + float obj3Dlifetime; // 52C + float audioLifetime; // 530 + float buildTime; // 534 + float innerRadius; // 538 + float outerRadius; // 53C + float imageSpaceRadius; // 540 + float damageMult; // 544 + BSSimpleList targetList; // 548 + BSTSmallArray soundHandles; // 558 + NiPointer light; // 588 + ObjectRefHandle owner; // 590 + ObjectRefHandle explodedRef; // 594 + ObjectRefHandle createdRef; // 598 + BSTSmartPointer actorCause; // 5A0 + NonActorMagicCaster* caster; // 5A8 + BGSObjectInstanceT weaponSource; // 5B0 + std::int32_t frameCount; // 5C0 + NiPoint3A closestPoint; // 5D0 + NiPoint3A closestPointNormal; // 5E0 + float calculatedDamage; // 5F0 + float scale; // 5F4 + REX::EnumSet flags; // 5F8 }; static_assert(sizeof(Explosion) == 0x600); } diff --git a/include/RE/E/ExtraAmmo.h b/include/RE/E/ExtraAmmo.h new file mode 100644 index 00000000..f5ddcd63 --- /dev/null +++ b/include/RE/E/ExtraAmmo.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/B/BSExtraData.h" + +namespace RE +{ + class __declspec(novtable) ExtraAmmo : + public BSExtraData // 00 + { + public: + static constexpr auto RTTI{ RTTI::ExtraAmmo }; + static constexpr auto VTABLE{ VTABLE::ExtraAmmo }; + static constexpr auto TYPE{ EXTRA_DATA_TYPE::kAmmo }; + + // members + std::uint32_t count; // 18 + }; + static_assert(sizeof(ExtraAmmo) == 0x20); +} diff --git a/include/RE/E/ExtraPoison.h b/include/RE/E/ExtraPoison.h new file mode 100644 index 00000000..94e1638e --- /dev/null +++ b/include/RE/E/ExtraPoison.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BSExtraData.h" + +namespace RE +{ + class AlchemyItem; + + class __declspec(novtable) ExtraPoison : + public BSExtraData // 00 + { + public: + static constexpr auto RTTI{ RTTI::ExtraPoison }; + static constexpr auto VTABLE{ VTABLE::ExtraPoison }; + static constexpr auto TYPE{ EXTRA_DATA_TYPE::kPoison }; + + // members + std::uint32_t count; // 18 + AlchemyItem* poison; // 20 + }; + static_assert(sizeof(ExtraPoison) == 0x28); +} diff --git a/include/RE/F/FavoritesManager.h b/include/RE/F/FavoritesManager.h index a23c2b34..098576b4 100644 --- a/include/RE/F/FavoritesManager.h +++ b/include/RE/F/FavoritesManager.h @@ -74,6 +74,13 @@ namespace RE return func(this, a_quickkeyIndex); } + [[nodiscard]] void ClearCurrentAmmoCount() + { + using func_t = decltype(&FavoritesManager::ClearCurrentAmmoCount); + static REL::Relocation func{ ID::FavoritesManager::ClearCurrentAmmoCount }; + return func(this); + } + // members TESBoundObject* storedFavTypes[12]; // 090 NiPointer bufferedFavGeometries[12]; // 0F0 diff --git a/include/RE/Fallout.h b/include/RE/Fallout.h index a03fb433..05f56c2f 100644 --- a/include/RE/Fallout.h +++ b/include/RE/Fallout.h @@ -12,6 +12,7 @@ #include "RE/A/ACTOR_CRITICAL_STAGE.h" #include "RE/A/ACTOR_LIFE_STATE.h" #include "RE/A/ACTOR_LOS_LOCATION.h" +#include "RE/A/ACTOR_MOVEMENT_TYPE.h" #include "RE/A/ACTOR_STANCE.h" #include "RE/A/ACTOR_VALUE_MODIFIER.h" #include "RE/A/ACTOR_VISIBILITY_MASK.h" @@ -23,6 +24,8 @@ #include "RE/A/AITimer.h" #include "RE/A/AMMO_DATA.h" #include "RE/A/ActionInput.h" +#include "RE/A/ActionOutput.h" +#include "RE/A/ActionPoints.h" #include "RE/A/ActiveEffect.h" #include "RE/A/ActiveEffectList.h" #include "RE/A/ActiveEffectReferenceEffectController.h" @@ -31,9 +34,11 @@ #include "RE/A/ActorEquipManagerEvent.h" #include "RE/A/ActorItemEquipped.h" #include "RE/A/ActorKill.h" +#include "RE/A/ActorMotionFeedbackData.h" #include "RE/A/ActorMovementData.h" #include "RE/A/ActorPackage.h" #include "RE/A/ActorPackageData.h" +#include "RE/A/ActorStance.h" #include "RE/A/ActorState.h" #include "RE/A/ActorUtils.h" #include "RE/A/ActorValue.h" @@ -54,6 +59,7 @@ #include "RE/A/AttackBlockHandler.h" #include "RE/A/AttackData.h" #include "RE/A/AutoMoveHandler.h" +#include "RE/A/AvoidAreaStruct.h" #include "RE/B/BGSAcousticSpace.h" #include "RE/B/BGSAction.h" #include "RE/B/BGSActorCellEvent.h" @@ -71,6 +77,7 @@ #include "RE/B/BGSAttackDataMap.h" #include "RE/B/BGSAttractionRule.h" #include "RE/B/BGSAudioEffectChain.h" +#include "RE/B/BGSAwakeSoundData.h" #include "RE/B/BGSBaseAlias.h" #include "RE/B/BGSBehaviorGraphModel.h" #include "RE/B/BGSBehaviorRootData.h" @@ -93,6 +100,9 @@ #include "RE/B/BGSCreatedObjectManager.h" #include "RE/B/BGSDamageType.h" #include "RE/B/BGSDebris.h" +#include "RE/B/BGSDecalEmitter.h" +#include "RE/B/BGSDecalGroup.h" +#include "RE/B/BGSDecalNode.h" #include "RE/B/BGSDefaultObject.h" #include "RE/B/BGSDefaultObjectManager.h" #include "RE/B/BGSDestructibleObjectForm.h" @@ -131,11 +141,13 @@ #include "RE/B/BGSInventoryListEvent.h" #include "RE/B/BGSKeyword.h" #include "RE/B/BGSKeywordForm.h" +#include "RE/B/BGSLOSData.h" #include "RE/B/BGSLargeRefData.h" #include "RE/B/BGSLensFlare.h" #include "RE/B/BGSLightingTemplate.h" #include "RE/B/BGSListForm.h" #include "RE/B/BGSLoadGameBuffer.h" +#include "RE/B/BGSLocAlias.h" #include "RE/B/BGSLocalizedString.h" #include "RE/B/BGSLocation.h" #include "RE/B/BGSLocationRefType.h" @@ -173,6 +185,7 @@ #include "RE/B/BGSProjectileData.h" #include "RE/B/BGSPropertySheet.h" #include "RE/B/BGSQuestInstanceText.h" +#include "RE/B/BGSQuestObjective.h" #include "RE/B/BGSRefAlias.h" #include "RE/B/BGSRefAliasInstanceData.h" #include "RE/B/BGSReferenceEffect.h" @@ -205,6 +218,7 @@ #include "RE/B/BGSSoundTagComponent.h" #include "RE/B/BGSSoundTagSet.h" #include "RE/B/BGSStaticCollection.h" +#include "RE/B/BGSStoryEvent.h" #include "RE/B/BGSStoryEventManager.h" #include "RE/B/BGSStoryManagerBranchNode.h" #include "RE/B/BGSStoryManagerEventNode.h" @@ -246,6 +260,7 @@ #include "RE/B/BSCubeMapCamera.h" #include "RE/B/BSCullingProcess.h" #include "RE/B/BSEventFlag.h" +#include "RE/B/BSExternalAudioIO.h" #include "RE/B/BSExtraData.h" #include "RE/B/BSFadeNode.h" #include "RE/B/BSFile.h" @@ -277,9 +292,11 @@ #include "RE/B/BSInputEventUser.h" #include "RE/B/BSIntrusiveRefCounted.h" #include "RE/B/BSLensFlareRenderData.h" +#include "RE/B/BSLensFlareSpriteData.h" #include "RE/B/BSLightingShaderMaterial.h" #include "RE/B/BSLightingShaderMaterialBase.h" #include "RE/B/BSLightingShaderProperty.h" +#include "RE/B/BSLog.h" #include "RE/B/BSMTAManager.h" #include "RE/B/BSMagicShaderParticles.h" #include "RE/B/BSMaterialObject.h" @@ -297,6 +314,9 @@ #include "RE/B/BSNavmeshEdgeExtraInfo.h" #include "RE/B/BSNavmeshGrid.h" #include "RE/B/BSNavmeshInfoMap.h" +#include "RE/B/BSNavmeshObstacleCoverData.h" +#include "RE/B/BSNavmeshTriHandle.h" +#include "RE/B/BSNavmeshTriLocation.h" #include "RE/B/BSNavmeshTriangle.h" #include "RE/B/BSNavmeshTriangleDoorPortal.h" #include "RE/B/BSNavmeshTriangleEdgePortal.h" @@ -307,7 +327,11 @@ #include "RE/B/BSOcclusionPlane.h" #include "RE/B/BSOcclusionShape.h" #include "RE/B/BSPackedTaskQueue.h" +#include "RE/B/BSPathingAvoidNode.h" +#include "RE/B/BSPathingFaceTarget.h" +#include "RE/B/BSPathingGoal.h" #include "RE/B/BSPathingLocation.h" +#include "RE/B/BSPathingStart.h" #include "RE/B/BSPointerAllocator.h" #include "RE/B/BSPointerHandle.h" #include "RE/B/BSPortal.h" @@ -411,7 +435,9 @@ #include "RE/B/BSScript_Variable.h" #include "RE/B/BSSemaphore.h" #include "RE/B/BSShader.h" +#include "RE/B/BSShaderAccumulator.h" #include "RE/B/BSShaderData.h" +#include "RE/B/BSShaderManager.h" #include "RE/B/BSShaderMaterial.h" #include "RE/B/BSShaderProperty.h" #include "RE/B/BSShaderPropertyLightData.h" @@ -480,10 +506,12 @@ #include "RE/B/BaseExtraList.h" #include "RE/B/BaseFormComponent.h" #include "RE/B/BaseLoadedInventoryModel.h" +#include "RE/B/BaseTreeData.h" #include "RE/B/BeamProjectile.h" #include "RE/B/BipedAnim.h" #include "RE/B/Bleedout.h" #include "RE/B/BobbleheadCollected.h" +#include "RE/B/BoneData.h" #include "RE/B/BooksRead.h" #include "RE/B/ButtonEvent.h" #include "RE/B/ButtonHintBar.h" @@ -504,14 +532,17 @@ #include "RE/C/CELLJobs.h" #include "RE/C/CFilter.h" #include "RE/C/CHANGE_TYPES.h" +#include "RE/C/CHARACTER_FLAGS.h" #include "RE/C/CHAR_NORM.h" #include "RE/C/CLASS_DATA.h" #include "RE/C/COL_LAYER.h" +#include "RE/C/COMMAND_REFUSAL_TYPE.h" #include "RE/C/COMMAND_TYPE.h" #include "RE/C/COMPILER_NAME.h" #include "RE/C/CONDITIONITEMOBJECT.h" #include "RE/C/CONDITION_ITEM_DATA.h" #include "RE/C/CONT_DATA.h" +#include "RE/C/COVER_TYPE.h" #include "RE/C/CachedValueData.h" #include "RE/C/CachedValues.h" #include "RE/C/Calendar.h" @@ -521,7 +552,9 @@ #include "RE/C/CellAttachDetachEventSource.h" #include "RE/C/CharacterEvent.h" #include "RE/C/ColorUpdateEvent.h" +#include "RE/C/CombatBehaviorStack.h" #include "RE/C/CombatFormulas.h" +#include "RE/C/CombatRange.h" #include "RE/C/CombatStyleCloseRangeData.h" #include "RE/C/CombatStyleCoverData.h" #include "RE/C/CombatStyleFlightData.h" @@ -543,6 +576,7 @@ #include "RE/C/ContainerMenuBase.h" #include "RE/C/ContainerObject.h" #include "RE/C/ControlMap.h" +#include "RE/C/CountdownTimer.h" #include "RE/C/CreateGrassParams.h" #include "RE/C/CreatureSounds.h" #include "RE/C/CrimeGoldStruct.h" @@ -553,10 +587,12 @@ #include "RE/C/CursorMenu.h" #include "RE/C/CursorMoveEvent.h" #include "RE/C/CustomMarkerUpdate.h" +#include "RE/D/DECAL_CREATION_DATA.h" #include "RE/D/DECAL_DATA_DATA.h" #include "RE/D/DEFAULT_OBJECT.h" #include "RE/D/DEFAULT_OBJECT_DATA.h" #include "RE/D/DEFAULT_OBJECT_TYPE.h" +#include "RE/D/DETECTION_PRIORITY.h" #include "RE/D/DIALOGUE_DATA.h" #include "RE/D/DIALOGUE_SUBTYPE.h" #include "RE/D/DIALOGUE_TYPE.h" @@ -564,13 +600,18 @@ #include "RE/D/DamageImpactData.h" #include "RE/D/DecalData.h" #include "RE/D/DefaultObjectFormFactory.h" +#include "RE/D/DeferredHideLimb.h" +#include "RE/D/DesiredMovementData.h" #include "RE/D/DestructibleObjectData.h" #include "RE/D/DestructibleObjectStage.h" #include "RE/D/DetectionEvent.h" +#include "RE/D/DetectionLevels.h" #include "RE/D/DeviceConnectEvent.h" +#include "RE/D/DialogueItem.h" #include "RE/D/DialogueMenu.h" #include "RE/D/DialogueMenuUtils.h" #include "RE/D/DialoguePackage.h" +#include "RE/D/DialogueResponse.h" #include "RE/D/DifficultyLevel.h" #include "RE/D/DisableHeavyItemsFunc.h" #include "RE/D/DisconnectHandler.h" @@ -604,6 +645,7 @@ #include "RE/E/Explosion.h" #include "RE/E/ExteriorCellSingleton.h" #include "RE/E/ExtraAliasInstanceArray.h" +#include "RE/E/ExtraAmmo.h" #include "RE/E/ExtraBendableSplineParams.h" #include "RE/E/ExtraCellWaterType.h" #include "RE/E/ExtraCharge.h" @@ -619,6 +661,7 @@ #include "RE/E/ExtraLock.h" #include "RE/E/ExtraMapMarker.h" #include "RE/E/ExtraMaterialSwap.h" +#include "RE/E/ExtraPoison.h" #include "RE/E/ExtraPowerLinks.h" #include "RE/E/ExtraRadioData.h" #include "RE/E/ExtraRadioReceiver.h" @@ -649,6 +692,7 @@ #include "RE/F/FriendshipFactionsStruct.h" #include "RE/G/GROUP_REACTION.h" #include "RE/G/GUN_STATE.h" +#include "RE/G/GameColorData.h" #include "RE/G/GameMenuBase.h" #include "RE/G/GamePlayFormulas.h" #include "RE/G/GameScript.h" @@ -667,8 +711,10 @@ #include "RE/H/HUDMenuUtils.h" #include "RE/H/HUDMeterType.h" #include "RE/H/HUDModeEvent.h" +#include "RE/H/HUDModeInitParams.h" #include "RE/H/HUDModeType.h" #include "RE/H/HUDModes.h" +#include "RE/H/HUDNotificationEvent.h" #include "RE/H/HUDPerkVaultBoyData.h" #include "RE/H/HUDPerkVaultBoySwfDisplayEvent.h" #include "RE/H/HUDSubtitleDisplayData.h" @@ -680,6 +726,8 @@ #include "RE/H/HolotapeMenu.h" #include "RE/H/HolotapeStateChanged.h" #include "RE/H/HourPassed.h" +#include "RE/H/hclTriangleBuffer.h" +#include "RE/H/hclVectorBuffer.h" #include "RE/H/hkAabb.h" #include "RE/H/hkArray.h" #include "RE/H/hkBaseObject.h" @@ -697,6 +745,8 @@ #include "RE/H/hkMemoryAllocator.h" #include "RE/H/hkPadSpu.h" #include "RE/H/hkPtrAndInt.h" +#include "RE/H/hkQsTransformf.h" +#include "RE/H/hkQuaternionf.h" #include "RE/H/hkRefPtr.h" #include "RE/H/hkReferencedObject.h" #include "RE/H/hkResult.h" @@ -716,6 +766,7 @@ #include "RE/H/hknpCharacterContext.h" #include "RE/H/hknpCharacterState.h" #include "RE/H/hknpCharacterSurfaceInfo.h" +#include "RE/H/hknpClosestUniqueBodyIdHitCollector.h" #include "RE/H/hknpCollisionDispatchType.h" #include "RE/H/hknpCollisionQuery.h" #include "RE/H/hknpCollisionQueryCollector.h" @@ -737,6 +788,7 @@ #include "RE/H/hknpShapeType.h" #include "RE/H/hknpSolverInfo.h" #include "RE/H/hknpThreadSafetyCheck.h" +#include "RE/H/hknpUniqueBodyIdHitCollector.h" #include "RE/H/hknpWorld.h" #include "RE/H/hknpWorldCinfo.h" #include "RE/H/hknpWorldSignals.h" @@ -763,11 +815,14 @@ #include "RE/I/INTERACTING_STATE.h" #include "RE/I/INTERACTION_EXIT.h" #include "RE/I/INTERIOR_DATA.h" +#include "RE/I/IPathFollowerState.h" #include "RE/I/IPipboyThrottledValue.h" #include "RE/I/IPostAnimationChannelUpdateFunctor.h" +#include "RE/I/ITEM_CHANGE_FILTER.h" #include "RE/I/ITEM_REMOVE_REASON.h" #include "RE/I/IUIMessageData.h" #include "RE/I/IdleInputEvent.h" +#include "RE/I/IdleMovementData.h" #include "RE/I/ImageSpaceBaseData.h" #include "RE/I/ImageSpaceData.h" #include "RE/I/ImageSpaceEffect.h" @@ -804,14 +859,18 @@ #include "RE/I/IsPipboyActiveEvent.h" #include "RE/I/ItemCrafted.h" #include "RE/J/JumpHandler.h" +#include "RE/K/KNOCK_STATE_ENUM.h" #include "RE/K/KeywordType.h" #include "RE/K/KinectEvent.h" +#include "RE/L/LANDING_TYPE.h" #include "RE/L/LEVELED_OBJECT.h" #include "RE/L/LOADED_CELL_DATA.h" #include "RE/L/LOADED_REF_DATA.h" #include "RE/L/LOCK_LEVEL.h" #include "RE/L/LevelIncrease.h" +#include "RE/L/LipSynchAnim.h" #include "RE/L/LoadingMenu.h" +#include "RE/L/LoadingMenuData.h" #include "RE/L/LoadingStatusChanged.h" #include "RE/L/LocalMapCameraUpdate.h" #include "RE/L/LocationMarkerArrayUpdate.h" @@ -848,17 +907,23 @@ #include "RE/M/Modifiers.h" #include "RE/M/Moon.h" #include "RE/M/MouseMoveEvent.h" +#include "RE/M/MoveData.h" #include "RE/M/Movement.h" +#include "RE/M/MovementCorrection.h" +#include "RE/M/MovementCorrectionData.h" #include "RE/M/MovementData.h" #include "RE/M/MovementLargeDelta.h" #include "RE/M/MovementTweenerOutputData.h" +#include "RE/M/MovementVector.h" #include "RE/N/NEW_REFR_DATA.h" #include "RE/N/NPC_DATA.h" #include "RE/N/NavMesh.h" #include "RE/N/NavMeshInfoMap.h" #include "RE/N/NiAVObject.h" #include "RE/N/NiAccumulator.h" +#include "RE/N/NiAlphaAccumulator.h" #include "RE/N/NiAlphaProperty.h" +#include "RE/N/NiBackToFrontAccumulator.h" #include "RE/N/NiBillboardNode.h" #include "RE/N/NiBinaryStream.h" #include "RE/N/NiBound.h" @@ -874,6 +939,7 @@ #include "RE/N/NiFile.h" #include "RE/N/NiFrustum.h" #include "RE/N/NiFrustumPlanes.h" +#include "RE/N/NiLight.h" #include "RE/N/NiMatrix3.h" #include "RE/N/NiMemManager.h" #include "RE/N/NiMemStream.h" @@ -881,6 +947,7 @@ #include "RE/N/NiNode.h" #include "RE/N/NiObject.h" #include "RE/N/NiObjectNET.h" +#include "RE/N/NiParticleInfo.h" #include "RE/N/NiPlane.h" #include "RE/N/NiPoint.h" #include "RE/N/NiPointer.h" @@ -907,6 +974,8 @@ #include "RE/N/NiUpdateData.h" #include "RE/N/NiVisibleArray.h" #include "RE/N/NonMorphFaceManagement.h" +#include "RE/N/nsHUDNotifications.h" +#include "RE/N/nsHUDTypes.h" #include "RE/N/nsStatsMenuUtils.h" #include "RE/O/OBJ_ARMA.h" #include "RE/O/OBJ_BOOK.h" @@ -1021,9 +1090,14 @@ #include "RE/R/RADIO_DATA.h" #include "RE/R/RADIO_RANGE_TYPE.h" #include "RE/R/RANK_DATA.h" +#include "RE/R/RECOIL_ENUM.h" #include "RE/R/REFR_LIGHT.h" #include "RE/R/REFR_LOCK.h" +#include "RE/R/REGION_DATA_BASE.h" +#include "RE/R/REGION_DATA_ID.h" #include "RE/R/RESET_3D_FLAGS.h" +#include "RE/R/RagDollBone.h" +#include "RE/R/RagDollData.h" #include "RE/R/ReadyWeaponHandler.h" #include "RE/R/ReanimateData.h" #include "RE/R/RefAttachTechniqueInput.h" @@ -1049,6 +1123,7 @@ #include "RE/S/SCRIPT_REFERENCED_OBJECT.h" #include "RE/S/SEX.h" #include "RE/S/SFRendererInitializedEvent.h" +#include "RE/S/SHAPE_TYPES.h" #include "RE/S/SIT_SLEEP_STATE.h" #include "RE/S/SOUND_LEVEL.h" #include "RE/S/SPECIALMenuEvent.h" @@ -1056,6 +1131,7 @@ #include "RE/S/SWFToCodeFunctionHandler.h" #include "RE/S/SavefileMetadata.h" #include "RE/S/SayOnceTimeStampStruct.h" +#include "RE/S/SayOnceTopicInfos.h" #include "RE/S/SceneGraph.h" #include "RE/S/ScrapHeap.h" #include "RE/S/ScrapItemCallback.h" @@ -1091,6 +1167,7 @@ #include "RE/S/SubtitleManager.h" #include "RE/S/SummonPlacementEffect.h" #include "RE/S/Sun.h" +#include "RE/S/SunOcclusionTest.h" #include "RE/T/TBO_InstanceData.h" #include "RE/T/TEMP_EFFECT_TYPE.h" #include "RE/T/TES.h" @@ -1190,7 +1267,9 @@ #include "RE/T/TESRaceForm.h" #include "RE/T/TESReactionForm.h" #include "RE/T/TESRegion.h" +#include "RE/T/TESRegionData.h" #include "RE/T/TESRegionList.h" +#include "RE/T/TESRegionPoint.h" #include "RE/T/TESResponse.h" #include "RE/T/TESShout.h" #include "RE/T/TESSoulGem.h" @@ -1212,6 +1291,7 @@ #include "RE/T/TESWeightForm.h" #include "RE/T/TESWordOfPower.h" #include "RE/T/TESWorldSpace.h" +#include "RE/T/TES_RETURN_CODE.h" #include "RE/T/TEXTURE_HAVOK_DATA.h" #include "RE/T/TLS.h" #include "RE/T/TOPIC_INFO_DATA.h" @@ -1228,6 +1308,7 @@ #include "RE/T/TextureUpdateStart.h" #include "RE/T/ThirdPersonState.h" #include "RE/T/ThumbstickEvent.h" +#include "RE/T/TrapData.h" #include "RE/T/TravelMarkerStateChange.h" #include "RE/T/TrespassPackage.h" #include "RE/T/TutorialEvent.h" @@ -1250,6 +1331,7 @@ #include "RE/U/UserEvents.h" #include "RE/U/UsesBSGFXFunctionHandler.h" #include "RE/V/VATS.h" +#include "RE/V/VATSCommand.h" #include "RE/V/VATSEvents.h" #include "RE/V/VOICE_TYPE_DATA.h" #include "RE/W/WARNING_TYPES.h" @@ -1259,6 +1341,7 @@ #include "RE/W/WEAPON_RUMBLE_PATTERN.h" #include "RE/W/WEAPON_STATE.h" #include "RE/W/WEAPON_TYPE.h" +#include "RE/W/WORLD_LOCATION.h" #include "RE/W/WORLD_MAP_DATA.h" #include "RE/W/WORLD_MAP_OFFSET_DATA.h" #include "RE/W/WadingWaterData.h" diff --git a/include/RE/G/GameColorData.h b/include/RE/G/GameColorData.h new file mode 100644 index 00000000..b3d957a9 --- /dev/null +++ b/include/RE/G/GameColorData.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/N/NiColor.h" + +namespace RE +{ + class GameColorData + { + public: + // members + NiColor gameplayHUDColor; // 00 + NiColor playerSetColor; // 0C + NiColor powerArmorHUDColor; // 18 + NiColor HUDWarningColor; // 24 + NiColor HUDAltWarningColor; // 30 + NiColor playerSetBackgroundColor; // 3C + NiColor powerArmorBackgroundColor; // 48 + NiColor gameplayHUDBackgroundColor; // 54 + }; + static_assert(sizeof(GameColorData) == 0x60); +} diff --git a/include/RE/G/GamePlayFormulas.h b/include/RE/G/GamePlayFormulas.h index 43529193..ba8dfb71 100644 --- a/include/RE/G/GamePlayFormulas.h +++ b/include/RE/G/GamePlayFormulas.h @@ -61,5 +61,12 @@ namespace RE static REL::Relocation func{ ID::GamePlayFormulas::GetHackingWordCount }; return func(a_playerIntelligence); } + + inline float GetForceLockChance(float a_playerPerception, std::int32_t a_lockLevel) + { + using func_t = decltype(&GamePlayFormulas::GetForceLockChance); + static REL::Relocation func{ ID::GamePlayFormulas::GetForceLockChance }; + return func(a_playerPerception, a_lockLevel); + } } } diff --git a/include/RE/G/GameScript.h b/include/RE/G/GameScript.h index 2f84d2dd..7bbb98fd 100644 --- a/include/RE/G/GameScript.h +++ b/include/RE/G/GameScript.h @@ -154,6 +154,23 @@ namespace RE return func(a_obj, a_error, a_vm, a_stackID, a_severity); } + class GetWorkshopResourceObjectsLinkedRefChildVisitor + { + public: + enum class OPTIONS : std::uint32_t + { + kAllObjects = 0x0, + kDamagedObjects = 0x1, + kUndamagedObjects = 0x2 + }; + + // members + BSScrapArray* array; // 00 + const ActorValueInfo* filter; // 08 + std::uint32_t option; // 10 + }; + static_assert(sizeof(GetWorkshopResourceObjectsLinkedRefChildVisitor) == 0x18); + class __declspec(novtable) DelayFunctor : public BSIntrusiveRefCounted // 08 { diff --git a/include/RE/G/GridCellArray.h b/include/RE/G/GridCellArray.h index ba84d9e4..10f2a913 100644 --- a/include/RE/G/GridCellArray.h +++ b/include/RE/G/GridCellArray.h @@ -20,10 +20,10 @@ namespace RE private: enum class ProgressiveAttatchState : std::int32_t { - PROGRESSIVE_ATTATCH_TO_WORLD = 0x0, - PROGRESSIVE_ATTATCH_MODELS = 0x1, - PROGRESSIVE_ATTATCH_REGISTER_COMBINED_OBJECT_VISIBILITY = 0x2, - PROGRESSIVE_ATTATCH_DONE = 0x3 + kToWorld = 0x0, + kModels = 0x1, + kRegisterCombinedObjectVisibility = 0x2, + kAttatchDone = 0x3 }; public: diff --git a/include/RE/H/HUDModeInitParams.h b/include/RE/H/HUDModeInitParams.h new file mode 100644 index 00000000..965e86b8 --- /dev/null +++ b/include/RE/H/HUDModeInitParams.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/P/POWER_ARMOR_HUD_VISIBILITY_RULE.h" + +namespace RE +{ + class HUDModeType; + + class HUDModeInitParams + { + public: + // members + const HUDModeType* validHUDModes; // 00 + std::uint32_t numHUDModes; // 08 + POWER_ARMOR_HUD_VISIBILITY_RULE powerArmorHUDVisibilityRule; // 0C + }; + static_assert(sizeof(HUDModeInitParams) == 0x10); +} diff --git a/include/RE/H/HUDNotificationEvent.h b/include/RE/H/HUDNotificationEvent.h new file mode 100644 index 00000000..fa707786 --- /dev/null +++ b/include/RE/H/HUDNotificationEvent.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/B/BSFixedString.h" +#include "RE/B/BSTOptional.h" +#include "RE/X/XPChangeData.h" + +namespace RE +{ + class BGSQuestObjective; + class MapMarkerData; + class TESQuest; + + class HUDNotificationEvent + { + public: + // members + BSFixedString messageType; // 00 + BSFixedStringCS messageTitle; // 08 + TESQuest* quest; // 10 + BGSQuestObjective* objective; // 18 + const MapMarkerData* markerData; // 20 + BSTOptional xpChange; // 28 + bool suppressNotification; // 3C + }; + static_assert(sizeof(HUDNotificationEvent) == 0x40); +} diff --git a/include/RE/H/HUDSubtitleDisplayData.h b/include/RE/H/HUDSubtitleDisplayData.h index 0432e6cc..9b8a5e70 100644 --- a/include/RE/H/HUDSubtitleDisplayData.h +++ b/include/RE/H/HUDSubtitleDisplayData.h @@ -7,6 +7,10 @@ namespace RE class HUDSubtitleDisplayData { public: + bool operator==(const HUDSubtitleDisplayData& a_rhs) { return speakerName == a_rhs.speakerName && subtitleText == a_rhs.subtitleText; } + + bool operator!=(const HUDSubtitleDisplayData& a_rhs) { return !operator==(a_rhs); } + // members BSFixedStringCS speakerName; // 00 BSFixedStringCS subtitleText; // 08 diff --git a/include/RE/H/hclTriangleBuffer.h b/include/RE/H/hclTriangleBuffer.h new file mode 100644 index 00000000..ac17dc48 --- /dev/null +++ b/include/RE/H/hclTriangleBuffer.h @@ -0,0 +1,17 @@ +#pragma once + +#include "RE/H/hkBool.h" + +namespace RE +{ + class hclTriangleBuffer + { + public: + // members + const void* bufferStart; // 00 + std::uint32_t numElements; // 08 + std::uint8_t stride; // 0C + hkBool use16BitsIndices; /// 0D + }; + static_assert(sizeof(hclTriangleBuffer) == 0x10); +} diff --git a/include/RE/H/hclVectorBuffer.h b/include/RE/H/hclVectorBuffer.h new file mode 100644 index 00000000..f917f269 --- /dev/null +++ b/include/RE/H/hclVectorBuffer.h @@ -0,0 +1,15 @@ +#pragma once + +namespace RE +{ + class hclVectorBuffer + { + public: + // members + void* bufferStart; // 00 + std::uint32_t numElements; // 08 + std::uint8_t stride; // 0C + std::uint32_t flags; // 10 + }; + static_assert(sizeof(hclVectorBuffer) == 0x18); +} diff --git a/include/RE/H/hkQsTransformf.h b/include/RE/H/hkQsTransformf.h new file mode 100644 index 00000000..649e9eff --- /dev/null +++ b/include/RE/H/hkQsTransformf.h @@ -0,0 +1,17 @@ +#pragma once + +#include "RE/H/hkQuaternionf.h" +#include "RE/H/hkVector4f.h" + +namespace RE +{ + class hkQsTransformf + { + public: + // members + hkVector4f translation; // 00 + hkQuaternionf rotation; // 10 + hkVector4f scale; // 20 + }; + static_assert(sizeof(hkQsTransformf) == 0x30); +} diff --git a/include/RE/H/hkQuaternionf.h b/include/RE/H/hkQuaternionf.h new file mode 100644 index 00000000..2033850c --- /dev/null +++ b/include/RE/H/hkQuaternionf.h @@ -0,0 +1,12 @@ +#pragma once + +namespace RE +{ + class hkQuaternionf + { + public: + // members + hkVector4f vec; // 00 + }; + static_assert(sizeof(hkQuaternionf) == 0x10); +} diff --git a/include/RE/H/hknpClosestUniqueBodyIdHitCollector.h b/include/RE/H/hknpClosestUniqueBodyIdHitCollector.h new file mode 100644 index 00000000..d73263b7 --- /dev/null +++ b/include/RE/H/hknpClosestUniqueBodyIdHitCollector.h @@ -0,0 +1,19 @@ +#pragma once + +#include "RE/H/hkVector4f.h" +#include "RE/H/hknpUniqueBodyIdHitCollector.h" + +namespace RE +{ + class __declspec(novtable) hknpClosestUniqueBodyIdHitCollector : + public hknpUniqueBodyIdHitCollector // 000 + { + public: + static constexpr auto RTTI{ RTTI::hknpClosestUniqueBodyIdHitCollector }; + static constexpr auto VTABLE{ VTABLE::hknpClosestUniqueBodyIdHitCollector }; + + // members + hkVector4f center; // 400 + }; + static_assert(sizeof(hknpClosestUniqueBodyIdHitCollector) == 0x410); +} diff --git a/include/RE/H/hknpUniqueBodyIdHitCollector.h b/include/RE/H/hknpUniqueBodyIdHitCollector.h new file mode 100644 index 00000000..77899e36 --- /dev/null +++ b/include/RE/H/hknpUniqueBodyIdHitCollector.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/H/hkRefPtr.h" +#include "RE/H/hknpAllHitsCollector.h" + +namespace RE +{ + class hknpBSWorld; + + class __declspec(novtable) hknpUniqueBodyIdHitCollector : + public hknpAllHitsCollector // 000 + { + public: + static constexpr auto RTTI{ RTTI::hknpUniqueBodyIdHitCollector }; + static constexpr auto VTABLE{ VTABLE::hknpUniqueBodyIdHitCollector }; + + // members + hkRefPtr latentWorld; // 3F0 + }; + static_assert(sizeof(hknpUniqueBodyIdHitCollector) == 0x400); +} diff --git a/include/RE/I/IPathFollowerState.h b/include/RE/I/IPathFollowerState.h new file mode 100644 index 00000000..12a6bead --- /dev/null +++ b/include/RE/I/IPathFollowerState.h @@ -0,0 +1,32 @@ +#pragma once + +namespace RE +{ + class BSPathingStreamRead; + class BSPathingStreamWrite; + class ICheckEndReachedFunctorMapper; + class MovementPlannerAgentReturnDataSmallDelta; + class MovementTweenerAgentOutputData; + class PathFollowerStateUpdateData; + + class IPathFollowerState + { + public: + static constexpr auto RTTI{ RTTI::IPathFollowerState }; + static constexpr auto VTABLE{ VTABLE::IPathFollowerState }; + + enum class PATH_FOLLOWER_STATE_RESULT : std::uint32_t + { + kContinue = 0x0, + kDone = 0x1 + }; + + virtual ~IPathFollowerState(); // 00 + + // add + virtual IPathFollowerState::PATH_FOLLOWER_STATE_RESULT Update(const PathFollowerStateUpdateData*, MovementPlannerAgentReturnDataSmallDelta*, MovementTweenerAgentOutputData*); // 01 + virtual void SaveGame(BSPathingStreamWrite*, const ICheckEndReachedFunctorMapper*) = 0; // 02 + virtual void LoadGame(BSPathingStreamRead*, const ICheckEndReachedFunctorMapper*) = 0; // 03 + }; + static_assert(sizeof(IPathFollowerState) == 0x8); +} diff --git a/include/RE/I/ITEM_CHANGE_FILTER.h b/include/RE/I/ITEM_CHANGE_FILTER.h new file mode 100644 index 00000000..4eb91828 --- /dev/null +++ b/include/RE/I/ITEM_CHANGE_FILTER.h @@ -0,0 +1,25 @@ +#pragma once + +namespace RE +{ + enum class ITEM_CHANGE_FILTER : std::uint32_t + { + kNone = 0x0, + kFavorites = 0x1, + kWeapons = 0x2, + kApparel = 0x4, + kAid = 0x8, + kScrolls = 0x10, + kFood = 0x20, + kIngredients = 0x40, + kBooks = 0x80, + kKeys = 0x100, + kMisc = 0x200, + kJunk = 0x400, + kMods = 0x800, + kAmmo = 0x1000, + kHolotapes = 0x2000, + kTotal = 0xE, + kAll = 0x3FFF + }; +} diff --git a/include/RE/I/IdleMovementData.h b/include/RE/I/IdleMovementData.h new file mode 100644 index 00000000..0f1c6fd4 --- /dev/null +++ b/include/RE/I/IdleMovementData.h @@ -0,0 +1,30 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class IdleMovementData + { + public: + // members + NiPoint3A translation; // 00 + NiPoint3A rotation; // 10 + NiPoint3A startVelocity; // 20 + NiPoint3A endVelocity; // 30 + NiPoint3A startRotSpeed; // 40 + NiPoint3A endRotSpeed; // 50 + NiPoint3A averageRotSpeed; // 60 + NiPoint3A translationUntilAllowRotation; // 70 + NiPoint3A velocityAtAllowRotation; // 80 + NiPoint3A rotSpeedAtAllowRotation; // 90 + float duration; // A0 + float tweenStart; // A4 + float tweenEnd; // A8 + float rotationTweenStart; // AC + float rotationTweenEnd; // B0 + float syncAnimTimes[4]; // B4 + bool usesAllowRotation; // C4 + }; + static_assert(sizeof(IdleMovementData) == 0xD0); +} diff --git a/include/RE/IDs.h b/include/RE/IDs.h index 50d3a441..9a7c0dea 100644 --- a/include/RE/IDs.h +++ b/include/RE/IDs.h @@ -150,6 +150,11 @@ namespace RE::ID inline constexpr REL::ID SetParentGroupNumber{ 2189125 }; } + namespace BGSConstructibleObject + { + inline constexpr REL::ID PlayerPassesConditions{ 2197318 }; + } + namespace BGSCraftItemEvent { inline constexpr REL::ID EventIndex{ 2663409 }; @@ -565,6 +570,7 @@ namespace RE::ID inline constexpr REL::ID UnsignedInt{ 2267950 }; inline constexpr REL::ID Float{ 2267953 }; inline constexpr REL::ID Float0To1{ 2267954 }; + inline constexpr REL::ID Int{ 2267952 }; } namespace BSResource_Archive2_AsyncReaderStream @@ -704,6 +710,10 @@ namespace RE::ID { inline constexpr REL::ID FadeInPlay{ 2267075 }; inline constexpr REL::ID FadeOutAndRelease{ 2267076 }; + inline constexpr REL::ID IsPlaying{ 2267046 }; + inline constexpr REL::ID Play{ 2276042 }; + inline constexpr REL::ID SetOutputModel{ 2267053 }; + inline constexpr REL::ID Stop{ 2267045 }; } namespace BSSpinLock @@ -746,6 +756,11 @@ namespace RE::ID inline constexpr REL::ID ctor{ 2212059 }; } + namespace BSTempEffectWeaponBlood + { + inline constexpr REL::ID ClearEffectForWeapon{ 2212158 }; + } + namespace BSTEvent { namespace BSTGlobalEvent @@ -780,6 +795,7 @@ namespace RE::ID inline constexpr REL::ID ConvertFloatToHalf{ 2212098 }; inline constexpr REL::ID ConvertHalfToFloat{ 2195843 }; inline constexpr REL::ID GetObjectByName{ 2274841 }; + inline constexpr REL::ID GetFlattenedBoneTree{ 2274858 }; } namespace Calendar @@ -826,6 +842,8 @@ namespace RE::ID inline constexpr REL::ID CalculateProjectileLOS2{ 2240616 }; inline constexpr REL::ID CalculateProjectileTrajectory{ 2240611 }; inline constexpr REL::ID WorldGravity{ 2700340 }; + inline constexpr REL::ID IsActorUsingMelee{ 2240626 }; + inline constexpr REL::ID IsActorUsingUnarmed{ 2240625 }; } namespace ComparisonQualifiers @@ -955,6 +973,7 @@ namespace RE::ID inline constexpr REL::ID UseQuickkeyItem{ 2248744 }; inline constexpr REL::ID HandleEvent{ 2248740 }; inline constexpr REL::ID Call{ 2248766 }; + inline constexpr REL::ID ClearCurrentAmmoCount{ 2248745 }; } namespace FlatScreenModel @@ -986,6 +1005,7 @@ namespace RE::ID inline constexpr REL::ID GetPickBreakSeconds{ 2209084 }; inline constexpr REL::ID GetHackingWordCount{ 2209067 }; inline constexpr REL::ID CalculateItemValue{ 2209074 }; + inline constexpr REL::ID GetForceLockChance{ 2209065 }; } namespace GameScript @@ -1338,6 +1358,21 @@ namespace RE::ID inline constexpr REL::ID SetAllowDegrade{ 2270148 }; } + namespace nsHUDNotifications + { + inline constexpr REL::ID IsQuestNotification{ 2222465 }; + inline constexpr REL::ID IsObjectiveNotification{ 2222466 }; + inline constexpr REL::ID IsLocationDiscoveredNotification{ 2222467 }; + } + + namespace nsHUDTypes + { + namespace NotificationInfo + { + inline constexpr REL::ID ctor{ 2223292 }; + } + } + namespace nsStatsMenuUtils { inline constexpr REL::ID GetEffectDisplayInfo{ 2224586 }; @@ -1360,7 +1395,7 @@ namespace RE::ID namespace PipboyInventoryData { - inline constexpr REL::ID RepopulateItemCardsOnSection{ 2225279 }; + inline constexpr REL::ID RepopulateItemCardOnSection{ 2225279 }; inline constexpr REL::ID PopulateItemCardInfo{ 2225266 }; inline constexpr REL::ID AddItemCardInfoEntry{ 2225267 }; inline constexpr REL::ID BaseAddItemCardInfoEntry{ 2225270 }; @@ -1860,6 +1895,11 @@ namespace RE::ID inline constexpr REL::ID GetEventSource{ 2201848 }; } + namespace TESLocationClearedEvent + { + inline constexpr REL::ID GetEventSource{ 2201849 }; + } + namespace TESMagicEffectApplyEvent { inline constexpr REL::ID GetEventSource{ 2201851 }; @@ -1976,6 +2016,11 @@ namespace RE::ID inline constexpr REL::ID GetEventSource{ 2201874 }; } + namespace TESTopic + { + inline constexpr REL::ID InitDialogueItem{ 2208360 }; + } + namespace TESTopicInfo { inline constexpr REL::ID GetParentInfoGroup{ 2208435 }; diff --git a/include/RE/K/KNOCK_STATE_ENUM.h b/include/RE/K/KNOCK_STATE_ENUM.h new file mode 100644 index 00000000..5c019a31 --- /dev/null +++ b/include/RE/K/KNOCK_STATE_ENUM.h @@ -0,0 +1,17 @@ +#pragma once + +namespace RE +{ + enum class KNOCK_STATE_ENUM : std::uint32_t + { + kNormal = 0x0, + kExplode = 0x1, + kExplodeLeadIn = 0x2, + kOut = 0x3, + kOutLeadIn = 0x4, + kQueued = 0x5, + kGetUp = 0x6, + kDown = 0x7, + kWaitForTaskQueue = 0x8 + }; +} diff --git a/include/RE/L/LANDING_TYPE.h b/include/RE/L/LANDING_TYPE.h new file mode 100644 index 00000000..f9c5a93a --- /dev/null +++ b/include/RE/L/LANDING_TYPE.h @@ -0,0 +1,11 @@ +#pragma once + +namespace RE +{ + enum class LANDING_TYPE : std::uint32_t + { + kDefault = 0x0, + kHasty = 0x1, + kCrash = 0x2 + }; +} diff --git a/include/RE/L/LipSynchAnim.h b/include/RE/L/LipSynchAnim.h new file mode 100644 index 00000000..08b55c26 --- /dev/null +++ b/include/RE/L/LipSynchAnim.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BSExternalAudioIO.h" + +namespace RE +{ + class LipSynchAnim + { + public: + // members + std::uint32_t numFrames; // 00 + std::int32_t startingFrame; // 04 + std::uint32_t numPhonemeTargets; // 08 + float** p_phonemes; // 10 + float** modifiers; // 18 + float* phonemes; // 20 + bool hasGestures; // 28 + std::uint32_t versionNumber; // 2C + BSExternalAudioIO::ExternalLoad voiceData; // 30; + }; + static_assert(sizeof(LipSynchAnim) == 0x48); +} diff --git a/include/RE/L/LoadingMenuData.h b/include/RE/L/LoadingMenuData.h new file mode 100644 index 00000000..35bc5e65 --- /dev/null +++ b/include/RE/L/LoadingMenuData.h @@ -0,0 +1,22 @@ +#pragma once + +#include "RE/B/BSFixedString.h" + +namespace RE +{ + class BGSLocation; + + class __declspec(novtable) LoadingMenuData : + public IUIMessageData // 00 + { + public: + static constexpr auto RTTI{ RTTI::LoadingMenuData }; + static constexpr auto VTABLE{ VTABLE::LoadingMenuData }; + + // members + BSFixedString action; // 18 + BGSLocation* location; // 20 + bool interior; // 28 + }; + static_assert(sizeof(LoadingMenuData) == 0x30); +} diff --git a/include/RE/M/MoveData.h b/include/RE/M/MoveData.h new file mode 100644 index 00000000..ec93c609 --- /dev/null +++ b/include/RE/M/MoveData.h @@ -0,0 +1,20 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class MoveData + { + public: + // members + NiPoint3A angle; // 00 + NiPoint3A displacement; // 10 + float time; // 20 + float currMoveSpeed; // 24 + bool visible; // 28 + bool deferMove; // 29 + bool forceAllowZTranslation; // 2A + }; + static_assert(sizeof(MoveData) == 0x30); +} diff --git a/include/RE/M/MovementCorrection.h b/include/RE/M/MovementCorrection.h new file mode 100644 index 00000000..5de3bdcb --- /dev/null +++ b/include/RE/M/MovementCorrection.h @@ -0,0 +1,28 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class MovementCorrection + { + public: + enum class CORRECTION_TYPE : std::uint32_t + { + kNone = 0x0, + kTargetPosVelAndIdle = 0x1, + kFixedDelta = 0x2, + kUpdateToFaceTarget = 0x3 + }; + + // members + MovementCorrection::CORRECTION_TYPE correctionType; // 00 + NiPoint3 parameters[10]; // 04 + float correctionStartTime; // 7C + float correctionEndTime; // 80 + float correctionStartRotateTime; // 84 + float correctionEndRotateTime; // 88 + float totalTime; // 8C + }; + static_assert(sizeof(MovementCorrection) == 0x90); +} diff --git a/include/RE/M/MovementCorrectionData.h b/include/RE/M/MovementCorrectionData.h new file mode 100644 index 00000000..96a1fa22 --- /dev/null +++ b/include/RE/M/MovementCorrectionData.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class MovementCorrectionData + { + public: + // members + NiPoint3 targetLocation; // 00 + NiPoint3 targetRotation; // 0C + NiPoint3 translationCorrection; // 18 + NiPoint3 rotationCorrection; // 24 + NiPoint3 startVelocity; // 30 + NiPoint3 endVelocity; // 3C + NiPoint3 startRotSpeed; // 48 + NiPoint3 endRotSpeed; // 54 + float correctionStartTime; // 60 + float correctionEndTime; // 64 + float correctionStartRotateTime; // 68 + float correctionEndRotateTime; // 6C + float totalTime; // 70 + }; + static_assert(sizeof(MovementCorrectionData) == 0x74); +} diff --git a/include/RE/M/MovementVector.h b/include/RE/M/MovementVector.h new file mode 100644 index 00000000..9d29ccee --- /dev/null +++ b/include/RE/M/MovementVector.h @@ -0,0 +1,15 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class MovementVector + { + public: + // members + NiPoint3A eulerAngles; // 00 + float speed; // 10 + }; + static_assert(sizeof(MovementVector) == 0x20); +} diff --git a/include/RE/N/NiAlphaAccumulator.h b/include/RE/N/NiAlphaAccumulator.h new file mode 100644 index 00000000..df609327 --- /dev/null +++ b/include/RE/N/NiAlphaAccumulator.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/N/NiBackToFrontAccumulator.h" + +namespace RE +{ + class __declspec(novtable) NiAlphaAccumulator : + public NiBackToFrontAccumulator // 00 + { + public: + static constexpr auto RTTI{ RTTI::NiAlphaAccumulator }; + static constexpr auto VTABLE{ VTABLE::NiAlphaAccumulator }; + static constexpr auto Ni_RTTI{ Ni_RTTI::NiAlphaAccumulator }; + + // members + bool observeNoSortHint; // 50 + bool sortByClosestPoint; // 51 + bool interfaceSort; // 52 + }; + static_assert(sizeof(NiAlphaAccumulator) == 0x58); +} diff --git a/include/RE/N/NiBackToFrontAccumulator.h b/include/RE/N/NiBackToFrontAccumulator.h new file mode 100644 index 00000000..78021a9c --- /dev/null +++ b/include/RE/N/NiBackToFrontAccumulator.h @@ -0,0 +1,27 @@ +#pragma once + +#include "RE/N/NiAccumulator.h" +#include "RE/N/NiTPointerList.h" + +namespace RE +{ + class BSGeometry; + + class __declspec(novtable) NiBackToFrontAccumulator : + public NiAccumulator // 000 + { + public: + static constexpr auto RTTI{ RTTI::NiBackToFrontAccumulator }; + static constexpr auto VTABLE{ VTABLE::NiBackToFrontAccumulator }; + static constexpr auto Ni_RTTI{ Ni_RTTI::NiBackToFrontAccumulator }; + + // members + NiTPointerList items; // 18 + std::int32_t numItems; // 30 + std::int32_t maxItems; // 34 + BSGeometry** pkItems; // 38 + float* depths; // 40 + std::int32_t currItem; // 48 + }; + static_assert(sizeof(NiBackToFrontAccumulator) == 0x50); +} diff --git a/include/RE/N/NiLight.h b/include/RE/N/NiLight.h new file mode 100644 index 00000000..e685c2ad --- /dev/null +++ b/include/RE/N/NiLight.h @@ -0,0 +1,26 @@ +#pragma once + +#include "RE/N/NiAVObject.h" +#include "RE/N/NiBound.h" +#include "RE/N/NiColor.h" + +namespace RE +{ + class __declspec(novtable) NiLight : + public NiAVObject // 000 + { + public: + static constexpr auto RTTI{ RTTI::NiLight }; + static constexpr auto VTABLE{ VTABLE::NiLight }; + static constexpr auto Ni_RTTI{ Ni_RTTI::NiLight }; + + // members + NiColor amb; // 120 + NiColor diff; // 12C + NiColor spec; // 138 + float dimmer; // 144 + alignas(16) NiBound modelBound; // 150 + void* rendererData; // 160 + }; + static_assert(sizeof(NiLight) == 0x170); +} diff --git a/include/RE/N/NiParticleInfo.h b/include/RE/N/NiParticleInfo.h new file mode 100644 index 00000000..8992c699 --- /dev/null +++ b/include/RE/N/NiParticleInfo.h @@ -0,0 +1,21 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class NiParticleInfo + { + public: + // members + NiPoint3 velocity; // 00 + float age; // 0C + float lifeSpan; // 10 + float lastUpdate; // 14 + std::uint16_t generation; // 18 + std::uint16_t code; // 1A + std::int16_t subTexFrame; // 1C + std::uint16_t subTexFrameCount; // 1E + }; + static_assert(sizeof(NiParticleInfo) == 0x20); +} diff --git a/include/RE/N/nsHUDNotifications.h b/include/RE/N/nsHUDNotifications.h new file mode 100644 index 00000000..204e6290 --- /dev/null +++ b/include/RE/N/nsHUDNotifications.h @@ -0,0 +1,30 @@ +#pragma once + +#include "RE/B/BSFixedString.h" + +namespace RE +{ + namespace nsHUDNotifications + { + [[nodiscard]] inline bool IsQuestNotification(const BSFixedString* a_type) + { + using func_t = decltype(&nsHUDNotifications::IsQuestNotification); + static REL::Relocation func{ ID::nsHUDNotifications::IsQuestNotification }; + return func(a_type); + } + + [[nodiscard]] inline bool IsObjectiveNotification(const BSFixedString* a_type) + { + using func_t = decltype(&nsHUDNotifications::IsObjectiveNotification); + static REL::Relocation func{ ID::nsHUDNotifications::IsObjectiveNotification }; + return func(a_type); + } + + [[nodiscard]] inline bool IsLocationDiscoveredNotification(const BSFixedString* a_type) + { + using func_t = decltype(&nsHUDNotifications::IsLocationDiscoveredNotification); + static REL::Relocation func{ ID::nsHUDNotifications::IsLocationDiscoveredNotification }; + return func(a_type); + } + } +} diff --git a/include/RE/N/nsHUDTypes.h b/include/RE/N/nsHUDTypes.h new file mode 100644 index 00000000..983d60c7 --- /dev/null +++ b/include/RE/N/nsHUDTypes.h @@ -0,0 +1,40 @@ +#pragma once + +#include "RE/B/BSFixedString.h" +#include "RE/B/BSTArray.h" +#include "RE/B/BSTOptional.h" +#include "RE/C/CountdownTimer.h" +#include "RE/X/XPChangeData.h" + +namespace RE +{ + class TESQuest; + + namespace nsHUDTypes + { + class ObjectiveData + { + public: + // members + BSFixedStringCS objectiveName; // 00 + bool completed; // 08 + bool orWithPrevious; // 09 + }; + static_assert(sizeof(ObjectiveData) == 0x10); + + class NotificationInfo + { + public: + // members + BSFixedStringCS title; // 00 + BSFixedStringCS prefix; // 08 + BSFixedStringCS soundName; // 10 + BSTArray objectives; // 18 + BSFixedString messageType; // 30 + TESQuest* quest; // 38 + CountdownTimer waitTime; // 40 + BSTOptional xpChange; // 58 + }; + static_assert(sizeof(NotificationInfo) == 0x70); + } +} diff --git a/include/RE/P/PipboyInventoryData.h b/include/RE/P/PipboyInventoryData.h index ea4c27ba..31c2058e 100644 --- a/include/RE/P/PipboyInventoryData.h +++ b/include/RE/P/PipboyInventoryData.h @@ -194,10 +194,10 @@ namespace RE virtual void DoClearData(); // 0D virtual void DoClearSink(); // 0E - void RepopulateItemCardsOnSection(ENUM_FORM_ID itemTypeID) + void RepopulateItemCardOnSection(ENUM_FORM_ID itemTypeID) { - using func_t = decltype(&PipboyInventoryData::RepopulateItemCardsOnSection); - static REL::Relocation func{ ID::PipboyInventoryData::RepopulateItemCardsOnSection }; + using func_t = decltype(&PipboyInventoryData::RepopulateItemCardOnSection); + static REL::Relocation func{ ID::PipboyInventoryData::RepopulateItemCardOnSection }; return func(this, itemTypeID); } diff --git a/include/RE/P/PlayerControls.h b/include/RE/P/PlayerControls.h index c89b194c..83a52e4c 100644 --- a/include/RE/P/PlayerControls.h +++ b/include/RE/P/PlayerControls.h @@ -48,6 +48,13 @@ namespace RE static constexpr auto RTTI{ RTTI::PlayerControls }; static constexpr auto VTABLE{ VTABLE::PlayerControls }; + enum class LERP_GRAPH + { + kMovementThird = 0x0, + kMovementFirst = 0x1, + kLooking = 0x2 + }; + static PlayerControls* GetSingleton() { static REL::Relocation singleton{ ID::PlayerControls::Singleton }; diff --git a/include/RE/P/Projectile.h b/include/RE/P/Projectile.h index 891a8710..b28da1c3 100644 --- a/include/RE/P/Projectile.h +++ b/include/RE/P/Projectile.h @@ -8,6 +8,8 @@ #include "RE/B/BSTArray.h" #include "RE/B/bhkCollisionQueryResultHandle.h" #include "RE/C/CELLJobs.h" +#include "RE/C/CFilter.h" +#include "RE/H/hknpBodyId.h" #include "RE/N/NiPoint.h" #include "RE/N/NiPointer.h" #include "RE/N/NiTransform.h" @@ -39,30 +41,44 @@ namespace RE static constexpr auto VTABLE{ VTABLE::Projectile }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kREFR }; - class ImpactCreation; + class ImpactCreation + { + public: + // members + NiPoint3A contactPoint; // 00 + NiPoint3A contactNormal; // 10 + TESObjectREFR* collidee; // 20 + CFilter collisionFilter; // 28 + hknpBodyId collisionBodyId; // 2C + std::uint32_t collisionShapeKey; // 30 + bool spellCast; // 34 + bool backface; // 35 + bool trigger; // 36 + }; + static_assert(sizeof(ImpactCreation) == 0x40); class ImpactData { public: // members - NiPoint3 location; // 00 - NiPoint3 normal; // 0C - bhkCollisionQueryResultHandle impactDecalQuery; // 18 - ObjectRefHandle collidee; // 20 - NiPointer colObj; // 28 - BGSMaterialType* materialType; // 30 - REX::EnumSet damageLimb; // 38 - REX::EnumSet collisionLayer; // 3C - NiPointer closestBone; // 40 - REX::EnumSet resultOverride; // 48 - float decalSize; // 4C - std::uint32_t collisionShapeKey; // 50 - std::int16_t targetWorldObjectCount; // 54 - std::int16_t targetWorldObjectIndex; // 56 - bool processed; // 58 - bool spellCast; // 59 - bool effectSpawned; // 5A - bool backface; // 5B + NiPoint3 location; // 00 + NiPoint3 normal; // 0C + bhkCollisionQueryResultHandle impactDecalQuery; // 18 + ObjectRefHandle collidee; // 20 + NiPointer colObj; // 28 + BGSMaterialType* materialType; // 30 + REX::EnumSet damageLimb; // 38 + REX::EnumSet collisionLayer; // 3C + NiPointer closestBone; // 40 + REX::EnumSet resultOverride; // 48 + float decalSize; // 4C + std::uint32_t collisionShapeKey; // 50 + std::int16_t targetWorldObjectCount; // 54 + std::int16_t targetWorldObjectIndex; // 56 + bool processed; // 58 + bool spellCast; // 59 + bool effectSpawned; // 5A + bool backface; // 5B }; static_assert(sizeof(ImpactData) == 0x60); @@ -105,46 +121,46 @@ namespace RE virtual bool ShouldUseDesiredTarget() { return false; } // E9 // members - BSTArray impacts; // 110 - NiTransform followOffset; // 130 - NiPointer collisionObject; // 170 - NiPointer droppedRefr; // 178 - NiPoint3 movementDirection; // 180 - NiPoint3 velocity; // 18C - NiPointer light; // 198 - NiPointer actorCause; // 1A0 - ObjectRefHandle shooter; // 1A8 - ObjectRefHandle desiredTarget; // 1AC - BSSoundHandle sndHandle; // 1B0 - BSSoundHandle sndCountdown; // 1B8 - BGSExplosion* explosion; // 1C0 - MagicItem* spell; // 1C8 - REX::EnumSet castingSource; // 1D0 - EffectSetting* avEffect; // 1D8 - NiPointer projectileDBFiles; // 1E0 - void* muzzleFlashDBHandle; // 1E8 - TODO - NiPointer muzzleFlashArt; // 1F0 - BSMagicShaderParticles* particles; // 1F8 - REX::EnumSet targetLimb; // 200 - NiPointer targetLimbObj; // 208 - NiAVObject* clonePoolKey; // 210 - float power; // 218 - float speedMult; // 21C - float range; // 220 - float age; // 224 - float damage; // 228 - float alpha; // 22C - float explosionTimer; // 230 - float blinkTimer; // 234 - BGSObjectInstanceT weaponSource; // 238 - TESAmmo* ammoSource; // 248 - BGSEquipIndex equipIndex; // 250 - float distanceMoved; // 254 - float movementDelta; // 258 - float scale; // 25C - std::uint64_t flags; // 260 - bool artRequested; // 268 - bool animationsLoaded; // 269 + BSTArray impacts; // 110 + NiTransform followOffset; // 130 + NiPointer collisionObject; // 170 + NiPointer droppedRefr; // 178 + NiPoint3 movementDirection; // 180 + NiPoint3 velocity; // 18C + NiPointer light; // 198 + NiPointer actorCause; // 1A0 + ObjectRefHandle shooter; // 1A8 + ObjectRefHandle desiredTarget; // 1AC + BSSoundHandle sndHandle; // 1B0 + BSSoundHandle sndCountdown; // 1B8 + BGSExplosion* explosion; // 1C0 + MagicItem* spell; // 1C8 + REX::EnumSet castingSource; // 1D0 + EffectSetting* avEffect; // 1D8 + NiPointer projectileDBFiles; // 1E0 + void* muzzleFlashDBHandle; // 1E8 - TODO + NiPointer muzzleFlashArt; // 1F0 + BSMagicShaderParticles* particles; // 1F8 + REX::EnumSet targetLimb; // 200 + NiPointer targetLimbObj; // 208 + NiAVObject* clonePoolKey; // 210 + float power; // 218 + float speedMult; // 21C + float range; // 220 + float age; // 224 + float damage; // 228 + float alpha; // 22C + float explosionTimer; // 230 + float blinkTimer; // 234 + BGSObjectInstanceT weaponSource; // 238 + TESAmmo* ammoSource; // 248 + BGSEquipIndex equipIndex; // 250 + float distanceMoved; // 254 + float movementDelta; // 258 + float scale; // 25C + std::uint64_t flags; // 260 + bool artRequested; // 268 + bool animationsLoaded; // 269 }; static_assert(sizeof(Projectile) == 0x270); } diff --git a/include/RE/P/ProjectileLaunchData.h b/include/RE/P/ProjectileLaunchData.h index c02e8de5..989c22fc 100644 --- a/include/RE/P/ProjectileLaunchData.h +++ b/include/RE/P/ProjectileLaunchData.h @@ -18,38 +18,38 @@ namespace RE { public: // members - NiPoint3 origin; // 00 - NiPoint3 contactNormal; // 0C - BGSProjectile* projectileBase; // 18 - TESObjectREFR* shooter; // 20 - CombatController* shooterCombatController; // 28 - BGSObjectInstanceT fromWeapon; // 30 - TESAmmo* fromAmmo; // 40 - BGSEquipIndex equipIndex; // 48 - float zAngle; // 4C - float xAngle; // 50 - float yAngle; // 54 - TESObjectREFR* homingTarget; // 58 - TESObjectCELL* parentCell; // 60 - MagicItem* spell; // 68 - REX::EnumSet castingSource; // 70 - AlchemyItem* poison; // 78 - std::int32_t area; // 80 - float power; // 84 - float scale; // 88 - float coneOfFireRadiusMult; // 8C - REX::EnumSet targetLimb; // 90 - bool alwaysHit; // 94 - bool noDamageOutsideCombat; // 95 - bool autoAim; // 96 - bool useOrigin; // 97 - bool deferInitialization; // 98 - bool tracer; // 99 - bool forceConeOfFire; // 9A - bool intentionalMiss; // 9B - bool allow3D; // 9C - bool penetrates; // 9D - bool ignoreNearCollisions; // 9E + NiPoint3 origin; // 00 + NiPoint3 contactNormal; // 0C + BGSProjectile* projectileBase; // 18 + TESObjectREFR* shooter; // 20 + CombatController* shooterCombatController; // 28 + BGSObjectInstanceT fromWeapon; // 30 + TESAmmo* fromAmmo; // 40 + BGSEquipIndex equipIndex; // 48 + float zAngle; // 4C + float xAngle; // 50 + float yAngle; // 54 + TESObjectREFR* homingTarget; // 58 + TESObjectCELL* parentCell; // 60 + MagicItem* spell; // 68 + REX::EnumSet castingSource; // 70 + AlchemyItem* poison; // 78 + std::int32_t area; // 80 + float power; // 84 + float scale; // 88 + float coneOfFireRadiusMult; // 8C + REX::EnumSet targetLimb; // 90 + bool alwaysHit; // 94 + bool noDamageOutsideCombat; // 95 + bool autoAim; // 96 + bool useOrigin; // 97 + bool deferInitialization; // 98 + bool tracer; // 99 + bool forceConeOfFire; // 9A + bool intentionalMiss; // 9B + bool allow3D; // 9C + bool penetrates; // 9D + bool ignoreNearCollisions; // 9E }; static_assert(sizeof(ProjectileLaunchData) == 0xA0); } diff --git a/include/RE/R/RECOIL_ENUM.h b/include/RE/R/RECOIL_ENUM.h new file mode 100644 index 00000000..be88e349 --- /dev/null +++ b/include/RE/R/RECOIL_ENUM.h @@ -0,0 +1,11 @@ +#pragma once + +namespace RE +{ + enum class RECOIL_ENUM + { + kNone = 0x0, + kSmall = 0x1, + kLarge = 0x2 + }; +} diff --git a/include/RE/R/REGION_DATA_BASE.h b/include/RE/R/REGION_DATA_BASE.h new file mode 100644 index 00000000..25a48032 --- /dev/null +++ b/include/RE/R/REGION_DATA_BASE.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/R/REGION_DATA_ID.h" + +namespace RE +{ + class REGION_DATA_BASE + { + public: + // members + REGION_DATA_ID dataTypeID; // 00 + bool override; // 04 + std::uint8_t priority; // 05 + }; + static_assert(sizeof(REGION_DATA_BASE) == 0x8); +} diff --git a/include/RE/R/REGION_DATA_ID.h b/include/RE/R/REGION_DATA_ID.h new file mode 100644 index 00000000..9c74c83a --- /dev/null +++ b/include/RE/R/REGION_DATA_ID.h @@ -0,0 +1,18 @@ +#pragma once + +namespace RE +{ + enum class REGION_DATA_ID : std::uint32_t + { + kNone = 0x0, + kGeneralID = 0x1, + kObjectsID = 0x2, + kWeatherID = 0x3, + kMapID = 0x4, + kLandscapeID = 0x5, + kGrassID = 0x6, + kSoundID = 0x7, + + kTotal = 0x8 + }; +} diff --git a/include/RE/R/RagDollBone.h b/include/RE/R/RagDollBone.h new file mode 100644 index 00000000..37385812 --- /dev/null +++ b/include/RE/R/RagDollBone.h @@ -0,0 +1,16 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class RagDollBone + { + public: + // members + char boneID; // 00 + NiPoint3 bonePos; // 04 + NiPoint3 boneRot; // 10 + }; + static_assert(sizeof(RagDollBone) == 0x1C); +} diff --git a/include/RE/R/RagDollData.h b/include/RE/R/RagDollData.h new file mode 100644 index 00000000..1c8f2922 --- /dev/null +++ b/include/RE/R/RagDollData.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class RagDollBone; + + class RagDollData + { + public: + // members + std::uint8_t boneCount; // 00 + RagDollBone* boneArray; // 08 + NiPoint3 bip01Rot; // 10 + }; + static_assert(sizeof(RagDollData) == 0x20); +} diff --git a/include/RE/S/SHAPE_TYPES.h b/include/RE/S/SHAPE_TYPES.h new file mode 100644 index 00000000..3fbeb06a --- /dev/null +++ b/include/RE/S/SHAPE_TYPES.h @@ -0,0 +1,13 @@ +#pragma once + +namespace RE +{ + enum class SHAPE_TYPES + { + kCapsule = 0x0, + kCustom = 0x0, + kConvex = 0x1, + kNumTypes = 0x2, + kInvalid = 0x2 + }; +} diff --git a/include/RE/S/SayOnceTopicInfos.h b/include/RE/S/SayOnceTopicInfos.h new file mode 100644 index 00000000..61617fa3 --- /dev/null +++ b/include/RE/S/SayOnceTopicInfos.h @@ -0,0 +1,16 @@ +#pragma once + +namespace RE +{ + class TESTopicInfo; + + class SayOnceTopicInfos + { + public: + // members + TESTopicInfo* info; // 00 + std::int32_t dateStamp; // 08 + float hourStamp; // 0C + }; + static_assert(sizeof(SayOnceTopicInfos) == 0x10); +} diff --git a/include/RE/S/ShaderReferenceEffect.h b/include/RE/S/ShaderReferenceEffect.h index 12c87de7..9294ed55 100644 --- a/include/RE/S/ShaderReferenceEffect.h +++ b/include/RE/S/ShaderReferenceEffect.h @@ -26,6 +26,17 @@ namespace RE ~ShaderReferenceEffect() override; + enum class Flag + { + kThirdPerson = 0x0, + kInterfaceEffect = 0x1, + kRestart = 0x2, + kAllTexturesAvailable = 0x3, + kParticleShadersStarted = 0x4, + kSuspended = 0x5, + kDisallowTargetRoot = 0x6 + }; + // members BSMagicShaderParticles particles; // 048 BSTArray*>> textureRequests; // 068 - TextureDB::Handle diff --git a/include/RE/S/Sky.h b/include/RE/S/Sky.h index 4ed95d95..c26fc73a 100644 --- a/include/RE/S/Sky.h +++ b/include/RE/S/Sky.h @@ -54,6 +54,25 @@ namespace RE kReleaseWeatherOverride = 1 << 21 }; + enum class WeatherStateOperation + { + kSave = 0x0, + kRestore = 0x1, + kClear = 0x2 + }; + + enum class FogDistance + { + kNear = 0x0, + kFar = 0x1, + kWaterNear = 0x2, + kWaterFar = 0x3, + kHeightMid = 0x4, + kHeightRange = 0x5, + kFarHeightMid = 0x6, + kFarHeightRange = 0x7 + }; + class SkyStaticRefData { public: diff --git a/include/RE/S/SunOcclusionTest.h b/include/RE/S/SunOcclusionTest.h new file mode 100644 index 00000000..91d3e26d --- /dev/null +++ b/include/RE/S/SunOcclusionTest.h @@ -0,0 +1,19 @@ +#pragma once + +namespace RE +{ + class BSGaphics + { + class OcclussionQuery; + }; + + class SunOcclusionTest + { + public: + BSGraphics::OcclusionQuery* occlusionQuery; // 00 + float percentOccluded; // 08 + std::uint32_t pixelCount; // 0C + std::uint32_t frameCount; // 10 + bool waiting; // 14 + }; +} diff --git a/include/RE/T/TES.h b/include/RE/T/TES.h index ca11b14d..936c17e4 100644 --- a/include/RE/T/TES.h +++ b/include/RE/T/TES.h @@ -56,6 +56,23 @@ namespace RE kSpecifiedWorldOnly = 0x4 }; + enum class TAC_CONTROL : std::uint32_t + { + kStop = 0xFFFFFFFF, + kContinue = 0x0, + kAllStandard = 0x1, + kInteriorsStandard = 0x2, + kStartInCurrentCell = 0x3, + kAllSaves = 0x4, + kAllSavesAfterChangingObjects = 0x5, + kAllRenderTest = 0x6, + kInteriorsRenderTest = 0x7, + kRegionFilter = 0x8, + kAllFileUsage = 0x9, + kAllGraphicsTest = 0xA, + kAllGraphicsTestLimited = 0xB + }; + class ParticleObjectCache { public: diff --git a/include/RE/T/TESActorBaseData.h b/include/RE/T/TESActorBaseData.h index 5d8df2c2..3a8f2690 100644 --- a/include/RE/T/TESActorBaseData.h +++ b/include/RE/T/TESActorBaseData.h @@ -14,6 +14,15 @@ namespace RE static constexpr auto RTTI{ RTTI::TESActorBaseData }; static constexpr auto VTABLE{ VTABLE::TESActorBaseData }; + enum class ALIGNMENT : std::uint32_t + { + kGood = 0x0, + kNeutral = 0x1, + kEvil = 0x2, + kVeryGood = 0x3, + kVeryEvil = 0x4 + }; + // add virtual void CopyFromTemplateForms([[maybe_unused]] TESActorBase** a_forceTemplates) { return; } // 07 virtual bool GetIsGhost() const; // 08 diff --git a/include/RE/T/TESClimate.h b/include/RE/T/TESClimate.h index 348c3e92..4152eb21 100644 --- a/include/RE/T/TESClimate.h +++ b/include/RE/T/TESClimate.h @@ -38,6 +38,12 @@ namespace RE kCount = 0x4 }; + enum class SpellContext + { + kApplyOnLightning = 0x0, + kApplyWhenActive = 0x1 + }; + // members TESModel nightSky; // 20 TESWeatherList weatherList; // 50 diff --git a/include/RE/T/TESImageSpaceModifier.h b/include/RE/T/TESImageSpaceModifier.h index cfc69d90..e322b737 100644 --- a/include/RE/T/TESImageSpaceModifier.h +++ b/include/RE/T/TESImageSpaceModifier.h @@ -18,6 +18,12 @@ namespace RE static constexpr auto VTABLE{ VTABLE::TESImageSpaceModifier }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kIMAD }; + enum class ImageSpaceModifierOperations + { + kMult = 0x0, + kAdd = 0x1, + }; + class ImageSpaceModifierData { public: diff --git a/include/RE/T/TESLoadScreen.h b/include/RE/T/TESLoadScreen.h index 4d09dc94..a8bf458c 100644 --- a/include/RE/T/TESLoadScreen.h +++ b/include/RE/T/TESLoadScreen.h @@ -3,10 +3,12 @@ #include "RE/B/BGSLocalizedString.h" #include "RE/T/TESCondition.h" #include "RE/T/TESForm.h" +#include "RE/T/TESModel.h" namespace RE { - class LoadNIFData; + class BGSTransform; + class TESBoundObject; class __declspec(novtable) TESLoadScreen : public TESForm // 00 @@ -16,6 +18,18 @@ namespace RE static constexpr auto VTABLE{ VTABLE::TESLoadScreen }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kLSCR }; + class LoadNIFData + { + public: + // members + TESBoundObject* loadNif; // 00 + std::int16_t rotationConstraints[2]; // 08 + TESModel cameraPath; // 10 + BGSTransform* transform; // 40 + float zoomConstraints[2]; // 48 + }; + static_assert(sizeof(LoadNIFData) == 0x50); + // members TESCondition conditions; // 20 LoadNIFData* loadNIFData; // 28 diff --git a/include/RE/T/TESLocationClearedEvent.h b/include/RE/T/TESLocationClearedEvent.h index 485a2931..616dee4a 100644 --- a/include/RE/T/TESLocationClearedEvent.h +++ b/include/RE/T/TESLocationClearedEvent.h @@ -5,6 +5,13 @@ namespace RE class TESLocationClearedEvent { public: + [[nodiscard]] static BSTEventSource* GetEventSource() + { + using func_t = decltype(&TESLocationClearedEvent::GetEventSource); + static REL::Relocation func{ ID::TESLocationClearedEvent::GetEventSource }; + return func(); + } + // members const BGSLocation* location; // 00 }; diff --git a/include/RE/T/TESObjectACTI.h b/include/RE/T/TESObjectACTI.h index 9933c392..116e43e0 100644 --- a/include/RE/T/TESObjectACTI.h +++ b/include/RE/T/TESObjectACTI.h @@ -32,6 +32,15 @@ namespace RE static constexpr auto VTABLE{ VTABLE::TESObjectACTI }; static constexpr auto FORM_ID{ ENUM_FORM_ID::kACTI }; + enum class ActiFlags + { + kNoDisplacement = 0x1, + kNoSandbox = 0x2, + kIsProceduralWater = 0x4, + kIsLODWater = 0x8, + kIsRadio = 0x10 + }; + // members BGSSoundDescriptorForm* soundLoop; // 128 BGSSoundDescriptorForm* soundActivate; // 130 diff --git a/include/RE/T/TESObjectCELL.h b/include/RE/T/TESObjectCELL.h index 4f95292c..80ac1177 100644 --- a/include/RE/T/TESObjectCELL.h +++ b/include/RE/T/TESObjectCELL.h @@ -48,6 +48,38 @@ namespace RE kAttached = 0x8 }; + enum class CELLNODE + { + kActor = 0x0, + kMarker = 0x1, + kLand = 0x2, + kStatic = 0x3, + kDynamic = 0x4, + kOcclusionPlane = 0x5, + kPortal = 0x6, + kMultibound = 0x7, + kCollision = 0x8, + kSmallObjects = 0x9, + kLightMarker = 0xA, + kSoundMarker = 0xB + }; + + enum class CELL_CULL_NODE + { + kActor = 0x0, + kMarker = 0x1, + kLand = 0x2, + kStatic = 0x3, + kDynamic = 0x4, + kOcclusionPlane = 0x5, + kPortal = 0x6, + kMultibound = 0x7, + kCollision = 0x8, + kLightMarker = 0x9, + kSoundMarker = 0xA, + kWater = 0xB + }; + enum class Flag { kInterior = 1u << 0, @@ -55,6 +87,32 @@ namespace RE kWarnToLeave = 1u << 9, }; + enum class QUAD_HIDE_STATE + { + kNormal = 0x0, + kCulled = 0x1, + kMissing = 0x2 + }; + + enum class MARKERNODECHILD + { + kLightMarker = 0x0, + kSoundMarker = 0x1 + }; + + class RENDER_DATA + { + public: + // members + std::uint32_t geometryCount; // 00 + std::uint32_t triangleCount; // 04 + std::uint32_t newRenderPassCoutn; // 08 + std::uint32_t activeLights; // 0C + std::uint64_t totalTime; // 10 + std::uint32_t accumulateTime; // 18 + }; + static_assert(sizeof(RENDER_DATA) == 0x20); + [[nodiscard]] bhkWorldM* GetbhkWorld() const { using func_t = decltype(&TESObjectCELL::GetbhkWorld); diff --git a/include/RE/T/TESRegionData.h b/include/RE/T/TESRegionData.h new file mode 100644 index 00000000..1bcfb09f --- /dev/null +++ b/include/RE/T/TESRegionData.h @@ -0,0 +1,33 @@ +#pragma once + +#include "RE/R/REGION_DATA_ID.h" + +namespace RE +{ + class REGION_DATA_BASE; + class TESRegion; + + class __declspec(novtable) TESRegionData + { + public: + static constexpr auto RTTI{ RTTI::TESRegionData }; + static constexpr auto VTABLE{ VTABLE::TESRegionData }; + + virtual ~TESRegionData(); // 00 + + // add + virtual bool LoadRegionData(REGION_DATA_BASE* a_data); // 01 + virtual void Initialize(TESRegion* a_formal); // 02 + virtual REGION_DATA_ID GetID(); // 03 + virtual TESRegionData* Copy(); // 04 + virtual TESRegionData* Blend(); // 04 + virtual void BlendInto(const TESRegionData* a_regionData, std::uint32_t a_totalBlending); // 05 + virtual bool Validate(); // 06 + + // members + bool override; // 08 + bool ignore; // 09 + std::uint8_t priority; // 0A + }; + static_assert(sizeof(TESRegionData) == 0x10); +} diff --git a/include/RE/T/TESRegionPoint.h b/include/RE/T/TESRegionPoint.h new file mode 100644 index 00000000..4dffdda6 --- /dev/null +++ b/include/RE/T/TESRegionPoint.h @@ -0,0 +1,14 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class TESRegionPoint + { + public: + // members + NiPoint2 point; // 00 + }; + static_assert(sizeof(TESRegionPoint) == 0x8); +} diff --git a/include/RE/T/TESTopic.h b/include/RE/T/TESTopic.h index 0f9f5138..a3981c27 100644 --- a/include/RE/T/TESTopic.h +++ b/include/RE/T/TESTopic.h @@ -2,6 +2,7 @@ #include "RE/B/BSFixedString.h" #include "RE/D/DIALOGUE_DATA.h" +#include "RE/D/DialogueItem.h" #include "RE/T/TESForm.h" #include "RE/T/TESFullName.h" @@ -32,6 +33,13 @@ namespace RE }; static_assert(sizeof(InfoTree) == 0x4); + bool InitDialogueItem(DialogueItem& a_outItem, TESObjectREFR* a_speaker, TESObjectREFR* a_target, TESTopicInfo* a_info, TESTopic* a_previousTopic, BSSimpleList* a_conversationList = nullptr) + { + using func_t = decltype(&TESTopic::InitDialogueItem); + static REL::Relocation func{ ID::TESTopic::InitDialogueItem }; + return func(this, a_outItem, a_speaker, a_target, a_info, a_previousTopic, a_conversationList); + } + // members DIALOGUE_DATA data; // 30 std::uint32_t priorityAndJournalIndex; // 34 diff --git a/include/RE/T/TES_RETURN_CODE.h b/include/RE/T/TES_RETURN_CODE.h new file mode 100644 index 00000000..abd34c1d --- /dev/null +++ b/include/RE/T/TES_RETURN_CODE.h @@ -0,0 +1,22 @@ +#pragma once + +namespace RE +{ + enum class TES_RETURN_CODE + { + kNone = 0x0, + kNotFound = 0x1, + kNoFile = 0x2, + kNoForm = 0x3, + kNoChunk = 0x4, + kNoID = 0x5, + kBadFile = 0x6, + kBadID = 0x7, + kFormOpen = 0x8, + kFileOpen = 0x9, + kWriteFailure = 0xA, + kInvalidFile = 0xB, + kFileInUse = 0xC, + kCreateFailure = 0xD + }; +} diff --git a/include/RE/T/TerminalMenu.h b/include/RE/T/TerminalMenu.h index f1a97582..ed96992a 100644 --- a/include/RE/T/TerminalMenu.h +++ b/include/RE/T/TerminalMenu.h @@ -40,8 +40,8 @@ namespace RE { public: // members - const void* menuItem; // 00 - BGSTerminal::MenuItem* - const BGSTerminal* terminal; // 08 + const BGSTerminal::MenuItem* menuItem; // 00 + const BGSTerminal* terminal; // 08 }; static_assert(sizeof(ListItem) == 0x10); diff --git a/include/RE/T/TrapData.h b/include/RE/T/TrapData.h new file mode 100644 index 00000000..f2345053 --- /dev/null +++ b/include/RE/T/TrapData.h @@ -0,0 +1,25 @@ +#pragma once + +#include "RE/B/BSPointerHandle.h" +#include "RE/H/hkVector4f.h" + +namespace RE +{ + class TrapData + { + public: + // members + ObjectRefHandle trap; // 00 + float damage; // 04 + float leveledDamage; // 08 + float minVelocity; // 0C + float pushBack; // 10 + float deathPushback; // 14 + float stagger; // 18 + bool continuous; // 1C + hkVector4f pushbackVector; // 20 + hkVector4f hitLocation; // 30 + std::uint32_t material; // 40 + }; + static_assert(sizeof(TrapData) == 0x50); +} diff --git a/include/RE/V/VATSCommand.h b/include/RE/V/VATSCommand.h new file mode 100644 index 00000000..e628db77 --- /dev/null +++ b/include/RE/V/VATSCommand.h @@ -0,0 +1,55 @@ +#pragma once + +#include "RE/A/ActionPoints.h" +#include "RE/B/BGSBodyPartDefs.h" +#include "RE/B/BSIntrusiveRefCounted.h" +#include "RE/B/BSPointerHandle.h" +#include "RE/H/HitData.h" +#include "RE/N/NiAVObject.h" +#include "RE/N/NiPointer.h" + +namespace RE +{ + class SpellItem; + + class VATSCommand : + public BSIntrusiveRefCounted // 000 + { + public: + // members + ActionPoints::Action action; // 004 + ObjectRefHandle target; // 008 + REX::EnumSet limb; // 00C + NiPointer aimAtObj; // 010 + HitData hitdata; // 20 + SpellItem* meleeImpactEffect; // 100 + float actionPointCost; // 108 + float minActionTime; // 10C + float actionExecuteDelay; // 110 + float fakeShotFrequency; // 114 + float damageMult; //118 + std::uint32_t loadedAmmoCount; // 11C + std::uint8_t fireShots; // 120 + struct + { + std::uint8_t stranger: 1; + std::uint8_t paralyzingPalm: 1; + std::uint8_t leftHandCast: 1; + std::uint8_t executeAction: 1; + std::uint8_t actionExecuteSuccess: 1; + std::uint8_t nextShotCausesCritical: 1; + std::uint8_t spendCriticalCharge: 1; + std::uint8_t attackChanceHit: 1; + } flags1; // 121 + struct + { + std::uint8_t shotFired: 1; + std::uint8_t criticalAttack: 1; + std::uint8_t syncedAnim: 1; + std::uint8_t attemptChain: 1; + std::uint8_t allowWarp: 1; + std::uint8_t meleeSneakAttack: 1; + } flags2; // 122 + }; + static_assert(sizeof(VATSCommand) == 0x130); +} diff --git a/include/RE/W/WORLD_LOCATION.h b/include/RE/W/WORLD_LOCATION.h new file mode 100644 index 00000000..bdcbb4f2 --- /dev/null +++ b/include/RE/W/WORLD_LOCATION.h @@ -0,0 +1,18 @@ +#pragma once + +#include "RE/N/NiPoint.h" + +namespace RE +{ + class TESForm; + + class WORLD_LOCATION + { + public: + // members + TESForm* locationForm; // 00 + NiPoint3 locPt; // 08 + float zRot; // 14 + }; + static_assert(sizeof(WORLD_LOCATION) == 0x18); +} diff --git a/include/Scaleform/M/MemoryHeap.h b/include/Scaleform/M/MemoryHeap.h index ee28f2c6..73264957 100644 --- a/include/Scaleform/M/MemoryHeap.h +++ b/include/Scaleform/M/MemoryHeap.h @@ -21,6 +21,25 @@ namespace Scaleform public: using ChildListType = List; + enum class HeapFlags + { + kThreadUnsafe = 0x1, + kFastTinyBlocks = 0x2, + kFixedGranularity = 0x4, + kRoot = 0x8, + kNoDebugInfo = 0x10, + kUserDebug = 0x1000 + }; + + enum class RootHeapParameters + { + kMinAlign = 0x10, + kGranularity = 0x4000, + kReserve = 0x4000, + kThreshold = 0x40000, + kLimit = 0x0 + }; + class HeapDesc { public: