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/BGSAwakeSoundData.h b/include/RE/B/BGSAwakeSoundData.h new file mode 100644 index 00000000..9451c14f --- /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 eState : std::uint32_t + { + kPlaying = 0x0, + kPaused = 0x1, + kStopped = 0x2, + + kTotal = 0x3 + }; + + BSSoundHandle sound; // 00 + std::uint32_t soundFormID; // 08 + float volume; // 0C + BGSAwakeSoundData::eState 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..e259a20b 100644 --- a/include/RE/B/BGSCharacterMorph.h +++ b/include/RE/B/BGSCharacterMorph.h @@ -96,5 +96,21 @@ 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 + }; } } 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/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/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/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/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/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/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/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..c29140dc --- /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 + BGSBodyPartDefs::LIMB_ENUM 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/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/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/Fallout.h b/include/RE/Fallout.h index a03fb433..d5046335 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,7 @@ #include "RE/B/BGSCreatedObjectManager.h" #include "RE/B/BGSDamageType.h" #include "RE/B/BGSDebris.h" +#include "RE/B/BGSDecalNode.h" #include "RE/B/BGSDefaultObject.h" #include "RE/B/BGSDefaultObjectManager.h" #include "RE/B/BGSDestructibleObjectForm.h" @@ -205,6 +213,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 +255,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 +287,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 +309,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,6 +322,8 @@ #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/BSPathingLocation.h" #include "RE/B/BSPointerAllocator.h" #include "RE/B/BSPointerHandle.h" @@ -411,7 +428,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" @@ -484,6 +503,7 @@ #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 +524,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 +544,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" @@ -557,6 +582,7 @@ #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 +590,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" @@ -619,6 +650,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 +681,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,6 +700,7 @@ #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/HUDPerkVaultBoyData.h" @@ -680,6 +714,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 +733,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 +754,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 +776,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 +803,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,13 +847,16 @@ #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/LoadingStatusChanged.h" #include "RE/L/LocalMapCameraUpdate.h" @@ -848,17 +894,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 +926,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 +934,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" @@ -1021,9 +1075,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 +1108,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 +1116,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 +1152,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 +1252,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 +1276,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 +1293,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 +1316,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 +1326,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/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/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..28d28ceb 100644 --- a/include/RE/IDs.h +++ b/include/RE/IDs.h @@ -704,6 +704,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 +750,11 @@ namespace RE::ID inline constexpr REL::ID ctor{ 2212059 }; } + namespace BSTempEffectWeaponBlood + { + inline constexpr REL::ID ClearEffectForWeapon{ 2212158 }; + } + namespace BSTEvent { namespace BSTGlobalEvent @@ -1976,6 +1985,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/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/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/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/TESObjectCELL.h b/include/RE/T/TESObjectCELL.h index 4f95292c..40227d84 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,19 @@ namespace RE kWarnToLeave = 1u << 9, }; + enum class QUAD_HIDE_STATE + { + kNormal = 0x0, + kCulled = 0x1, + kMissing = 0x2 + }; + + enum class MARKERNODECHILD + { + kLightMarker = 0x0, + kSoundMarker = 0x1 + }; + [[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/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..c6e57333 --- /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 + BGSBodyPartDefs::LIMB_ENUM 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: