docs: add plugin setup guide
This commit is contained in:
@@ -0,0 +1,101 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class MARKER_TYPE : std::uint32_t
|
||||
{
|
||||
kCave = 0x0,
|
||||
kCity = 0x1,
|
||||
kDiamondCity = 0x2,
|
||||
kEncampment = 0x3,
|
||||
kIndustrial = 0x4,
|
||||
kGovtBuilding = 0x5,
|
||||
kMetro = 0x6,
|
||||
kMilitaryBase = 0x7,
|
||||
kLandmark = 0x8,
|
||||
kOffice = 0x9,
|
||||
kRuinsTown = 0xA,
|
||||
kRuinsUrban = 0xB,
|
||||
kSanctuary = 0xC,
|
||||
kSettlement = 0xD,
|
||||
kSewer = 0xE,
|
||||
kVault = 0xF,
|
||||
kAirfield = 0x10,
|
||||
kBunkerHill = 0x11,
|
||||
kCamper = 0x12,
|
||||
kCar = 0x13,
|
||||
kChurch = 0x14,
|
||||
kCountryClub = 0x15,
|
||||
kCustomHouse = 0x16,
|
||||
kDriveIn = 0x17,
|
||||
kElevatedHighway = 0x18,
|
||||
kFaneuilHall = 0x19,
|
||||
kFarm = 0x1A,
|
||||
kFillingStation = 0x1B,
|
||||
kForest = 0x1C,
|
||||
kGoodNeighbor = 0x1D,
|
||||
kGraveyard = 0x1E,
|
||||
kHospital = 0x1F,
|
||||
kIndustrialDome = 0x20,
|
||||
kIndustrialStacks = 0x21,
|
||||
kInstitute = 0x22,
|
||||
kIrishPride = 0x23,
|
||||
kJunkyard = 0x24,
|
||||
kObservatory = 0x25,
|
||||
kPier = 0x26,
|
||||
kPondOrLake = 0x27,
|
||||
kQuarry = 0x28,
|
||||
kRadioactiveArea = 0x29,
|
||||
kRadioTower = 0x2A,
|
||||
kSalem = 0x2B,
|
||||
kSchool = 0x2C,
|
||||
kShipwreck = 0x2D,
|
||||
kSubmarine = 0x2E,
|
||||
kSwanPond = 0x2F,
|
||||
kSynthHead = 0x0,
|
||||
kTown = 0x31,
|
||||
kBOS = 0x32,
|
||||
kBrownstone = 0x33,
|
||||
kBunker = 0x34,
|
||||
kCastle = 0x35,
|
||||
kSkyscraper = 0x36,
|
||||
kLibertalia = 0x37,
|
||||
kLowrise = 0x38,
|
||||
kMinutemen = 0x39,
|
||||
kPoliceStation = 0x3A,
|
||||
kPrydwen = 0x3B,
|
||||
kRailroadFaction = 0x3C,
|
||||
kRailroad = 0x3D,
|
||||
kSatellite = 0x3E,
|
||||
kSentinel = 0x3F,
|
||||
kUSSConstitution = 0x40,
|
||||
kMechanist = 0x41,
|
||||
kRaiderSettlement = 0x42,
|
||||
kVassalSettlement = 0x43,
|
||||
kPotentialVassalSettlement = 0x44,
|
||||
kBottlingPlant = 0x45,
|
||||
kGalactic = 0x46,
|
||||
kHub = 0x47,
|
||||
kKiddieKingdom = 0x48,
|
||||
kMonorail = 0x49,
|
||||
kRides = 0x4A,
|
||||
kSafari = 0x4B,
|
||||
kWildWest = 0x4C,
|
||||
kPOI = 0x4D,
|
||||
kDisciples = 0x4E,
|
||||
kOperators = 0x4F,
|
||||
kPack = 0x50,
|
||||
kDoor = 0x51,
|
||||
kCountEditor = 0x52,
|
||||
kQuest = 0x53,
|
||||
kQuestDoor = 0x54,
|
||||
kQuestMultiple = 0x55,
|
||||
kPlayerSet = 0x56,
|
||||
kPlayerLocation = 0x57,
|
||||
kPowerArmorLocation = 0x58,
|
||||
kDogmeat = 0x59,
|
||||
kTeammate = 0x5A,
|
||||
|
||||
kCountTotal = 0x5B
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class MELEE_ATTACK_SPEED : std::int32_t
|
||||
{
|
||||
kVerySlow = 0x0,
|
||||
kSlow = 0x1,
|
||||
kMedium = 0x2,
|
||||
kFast = 0x3,
|
||||
kVeryFast = 0x4
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class MENU_RENDER_CONTEXT : std::int32_t
|
||||
{
|
||||
kMenuDelete = 0x0,
|
||||
kPreDisplay = 0x1,
|
||||
kRenderScreenspace = 0x2,
|
||||
kRenderCopyQuads = 0x3,
|
||||
kRenderImagespace = 0x4,
|
||||
kEnsureDisplayMenuCalled = 0x5,
|
||||
kPostDisplay = 0x6
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BGSLocalizedString.h"
|
||||
#include "RE/T/TESCondition.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MESSAGEBOX_BUTTON
|
||||
{
|
||||
public:
|
||||
// members
|
||||
BGSLocalizedString text; // 00
|
||||
TESCondition conditions; // 08
|
||||
};
|
||||
static_assert(sizeof(MESSAGEBOX_BUTTON) == 0x10);
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MOVABLE_STATIC_DATA
|
||||
{
|
||||
public:
|
||||
// members
|
||||
std::int8_t flags; // 0
|
||||
};
|
||||
static_assert(sizeof(MOVABLE_STATIC_DATA) == 0x1);
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BGSKeywordForm.h"
|
||||
#include "RE/B/BSTArray.h"
|
||||
#include "RE/B/BSTSmartPointer.h"
|
||||
#include "RE/T/TESBoundObject.h"
|
||||
#include "RE/T/TESFullName.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class QueuedFile;
|
||||
|
||||
namespace MagicSystem
|
||||
{
|
||||
enum class CastingType;
|
||||
enum class Delivery;
|
||||
enum class SpellType;
|
||||
}
|
||||
|
||||
class __declspec(novtable) MagicItem :
|
||||
public TESBoundObject, // 00
|
||||
public TESFullName, // 68
|
||||
public BGSKeywordForm // 70
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MagicItem };
|
||||
static constexpr auto VTABLE{ VTABLE::MagicItem };
|
||||
static constexpr auto FORM_ID{ ENUM_FORM_ID::kNONE };
|
||||
|
||||
class SkillUsageData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
EffectItem* effect; // 00
|
||||
ActorValueInfo* skill; // 08
|
||||
float magnitude; // 10
|
||||
bool custom; // 14
|
||||
};
|
||||
static_assert(sizeof(SkillUsageData) == 0x18);
|
||||
|
||||
class Data
|
||||
{
|
||||
public:
|
||||
// members
|
||||
std::int32_t costOverride; // 0
|
||||
std::uint32_t flags; // 4
|
||||
};
|
||||
static_assert(sizeof(Data) == 0x8);
|
||||
|
||||
// add
|
||||
virtual MagicSystem::SpellType GetSpellType() const = 0; // 67
|
||||
virtual void SetCastingType([[maybe_unused]] MagicSystem::CastingType a_castingType) { return; } // 68
|
||||
virtual MagicSystem::CastingType GetCastingType() const = 0; // 69
|
||||
virtual void SetDelivery([[maybe_unused]] MagicSystem::Delivery a_delivery) { return; } // 6A
|
||||
virtual MagicSystem::Delivery GetDelivery() const = 0; // 6B
|
||||
virtual bool IsValidDelivery(MagicSystem::Delivery) { return true; } // 6C
|
||||
virtual float GetFixedCastDuration() const { return 0.0F; } // 6D
|
||||
virtual float GetRange() const { return 0.0F; } // 6E
|
||||
virtual bool IgnoreResistance() const { return false; } // 6F
|
||||
virtual bool IgnoreLOS() const { return false; } // 70
|
||||
virtual bool IsFood() const { return false; } // 71
|
||||
virtual bool GetNoAbsorb() const { return false; } // 72
|
||||
virtual bool GetNoDualCastModifications() const { return false; } // 73
|
||||
virtual bool GetSkillUsageData([[maybe_unused]] SkillUsageData& a_data) const { return false; } // 74
|
||||
virtual bool IsPoison() const; // 75
|
||||
virtual bool IsMedicine() const { return false; } // 76
|
||||
virtual void AdjustCost(float&, Actor*) const { return; } // 77
|
||||
virtual float GetChargeTime() const { return 0.0F; } // 78
|
||||
virtual std::uint32_t GetMaxEffectCount() const { return 0; } // 79
|
||||
virtual ActorValueInfo* GetAssociatedSkill() const { return nullptr; } // 7A
|
||||
virtual bool IsTwoHanded() const { return false; } // 7B
|
||||
virtual CHUNK_ID GetChunkID() = 0; // 7C
|
||||
virtual void CopyMagicItemData(MagicItem* a_copy) = 0; // 7D
|
||||
virtual void LoadMagicItemChunk([[maybe_unused]] TESFile* a_file, [[maybe_unused]] CHUNK_ID a_chunkID) { return; } // 7E
|
||||
virtual void LoadChunkDataPostProcess([[maybe_unused]] TESFile* a_file) { return; } // 7F
|
||||
virtual Data* GetData() = 0; // 81
|
||||
virtual const Data* GetData() const = 0; // 80
|
||||
virtual std::size_t GetDataSize() const = 0; // 82
|
||||
virtual void InitFromChunk(TESFile* a_file) = 0; // 83
|
||||
|
||||
// members
|
||||
BSTArray<EffectItem*> listOfEffects; // 98
|
||||
std::int32_t hostileCount; // B0
|
||||
EffectSetting* avEffectSetting; // B8
|
||||
std::uint32_t preloadCount; // C0
|
||||
BSTSmartPointer<QueuedFile, BSTSmartPointerGamebryoRefCount> preloadedItem; // C8
|
||||
};
|
||||
static_assert(sizeof(MagicItem) == 0xD0);
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class ActiveEffectList;
|
||||
|
||||
class __declspec(novtable) MagicTarget
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MagicTarget };
|
||||
static constexpr auto VTABLE{ VTABLE::MagicTarget };
|
||||
|
||||
class AddTargetData;
|
||||
class SpellDispelData;
|
||||
|
||||
// members
|
||||
virtual ~MagicTarget(); // 00
|
||||
|
||||
// add
|
||||
virtual bool AddTarget(AddTargetData& a_data); // 01
|
||||
virtual TESObjectREFR* GetTargetStatsObject() { return nullptr; } // 02
|
||||
virtual bool MagicTargetIsActor() { return false; } // 03
|
||||
virtual bool IsInvulnerable() const { return false; } // 04
|
||||
virtual void InvalidateCommandedActorEffect([[maybe_unused]] ActiveEffect* a_effect) { return; } // 05
|
||||
virtual bool CanAddActiveEffect() const = 0; // 06
|
||||
virtual ActiveEffectList* GetActiveEffectList() = 0; // 07
|
||||
virtual float CheckResistance([[maybe_unused]] MagicItem* a_spell, [[maybe_unused]] EffectItem* a_effect, [[maybe_unused]] TESBoundObject* a_source) const { return 1.0F; } // 08
|
||||
virtual void EffectAdded([[maybe_unused]] ActiveEffect* a_effect) { return; } // 09
|
||||
virtual void EffectRemoved([[maybe_unused]] ActiveEffect* a_effect) { return; } // 0A
|
||||
virtual void EffectActiveStatusChanged([[maybe_unused]] ActiveEffect* a_effect) { return; } // 0B
|
||||
virtual bool CheckAbsorb([[maybe_unused]] Actor* a_caster, [[maybe_unused]] MagicItem* a_spell, [[maybe_unused]] const EffectItem* a_effectItem) { return false; } // 0C
|
||||
|
||||
[[nodiscard]] bool IsTakingHealthDamageFromActiveEffect()
|
||||
{
|
||||
using func_t = decltype(&MagicTarget::IsTakingHealthDamageFromActiveEffect);
|
||||
static REL::Relocation<func_t> func{ ID::MagicTarget::IsTakingHealthDamageFromActiveEffect };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
[[nodiscard]] bool IsTakingRadDamageFromActiveEffect()
|
||||
{
|
||||
using func_t = decltype(&MagicTarget::IsTakingRadDamageFromActiveEffect);
|
||||
static REL::Relocation<func_t> func{ ID::MagicTarget::IsTakingRadDamageFromActiveEffect };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
// members
|
||||
SpellDispelData* postUpdateDispelList; // 08
|
||||
std::int8_t flags; // 10
|
||||
};
|
||||
static_assert(sizeof(MagicTarget) == 0x18);
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSPackedTaskQueue.h"
|
||||
#include "RE/B/BSPointerHandle.h"
|
||||
#include "RE/B/BSSaveDataSystemUtilityImage.h"
|
||||
#include "RE/B/BSTArray.h"
|
||||
#include "RE/B/BSTEvent.h"
|
||||
#include "RE/B/BSTTuple.h"
|
||||
#include "RE/N/NiPointer.h"
|
||||
#include "RE/S/ScrapHeap.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class NiCamera;
|
||||
class SceneGraph;
|
||||
class TESPageCache;
|
||||
class PositionPlayerEvent;
|
||||
|
||||
class Main :
|
||||
public BSTEventSink<PositionPlayerEvent>
|
||||
{
|
||||
public:
|
||||
virtual ~Main(); // 00
|
||||
|
||||
[[nodiscard]] static Main* GetSingleton()
|
||||
{
|
||||
static REL::Relocation<Main**> singleton{ ID::Main::Singleton };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
// override
|
||||
virtual BSEventNotifyControl ProcessEvent(const PositionPlayerEvent& a_event, BSTEventSource<PositionPlayerEvent>* a_source) override; // 01
|
||||
|
||||
[[nodiscard]] static NiCamera* WorldRootCamera()
|
||||
{
|
||||
using func_t = decltype(&Main::WorldRootCamera);
|
||||
static REL::Relocation<func_t> func{ ID::Main::WorldRootCamera };
|
||||
return func();
|
||||
}
|
||||
|
||||
[[nodiscard]] static SceneGraph* WorldRootNode()
|
||||
{
|
||||
static REL::Relocation<NiPointer<SceneGraph>*> nodePtr{ ID::Main::WorldRootCamera };
|
||||
return nodePtr->get();
|
||||
}
|
||||
|
||||
[[nodiscard]] static bool QGameSystemsShouldUpdate()
|
||||
{
|
||||
static REL::Relocation<bool*> singleton{ ID::Main::QGameSystemsShouldUpdate };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
[[nodiscard]] static bool QGameDataLoaded()
|
||||
{
|
||||
static REL::Relocation<bool*> singleton{ ID::Main::QGameDataLoaded };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
void SetCameraFOV(float a_fov)
|
||||
{
|
||||
using func_t = decltype(&Main::SetCameraFOV);
|
||||
static REL::Relocation<func_t> func{ ID::Main::SetCameraFOV };
|
||||
return func(this, a_fov);
|
||||
}
|
||||
|
||||
// members
|
||||
BSTArray<BSTTuple<float, ActorHandle>> sortedVisibleHighActors; // 08
|
||||
std::uint32_t localMapRenderDelay; // 20
|
||||
bool quitGame; // 24
|
||||
bool resetGame; // 25
|
||||
bool fullReset; // 26
|
||||
bool gameActive; // 27
|
||||
bool onIdle; // 28
|
||||
bool reloadContent; // 29
|
||||
bool freezeTime; // 2A
|
||||
bool freezeNextFrame; // 2B
|
||||
REX::W32::HWND hwnd; // 30
|
||||
void* instance; // 38
|
||||
std::uint32_t threadID; // 40
|
||||
ScrapHeap packedTaskHeap; // 48
|
||||
BSPackedTaskQueue taskQueue; // D8
|
||||
ScrapHeap secondaryPackedTaskHeap; // 108
|
||||
BSPackedTaskQueue secondaryTaskQueue; // 198
|
||||
TESPageCache* pageCache; // 1C8
|
||||
bool inMenuMode; // 1D0
|
||||
bool inDialog; // 1D1
|
||||
bool renderingMenuBG; // 1D2
|
||||
bool signOutPending; // 1D3
|
||||
BSSaveDataSystemUtilityImage saveDataBackgroundImages[3]; // 1D8
|
||||
BSSaveDataSystemUtilityImage saveDataIconImages[3]; // 220
|
||||
};
|
||||
static_assert(sizeof(Main) == 0x268);
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSScaleformExternalTexture.h"
|
||||
#include "RE/B/BSTHashMap.h"
|
||||
#include "RE/S/StartMenuBase.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MainMenu :
|
||||
public StartMenuBase,
|
||||
public BSTEventSink<MenuOpenCloseEvent>
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MainMenu };
|
||||
static constexpr auto VTABLE{ VTABLE::MainMenu };
|
||||
static constexpr auto MENU_NAME{ "MainMenu"sv };
|
||||
|
||||
enum class MAIN_MENU_EXIT_CONDITION : std::int32_t
|
||||
{
|
||||
kNoExit = 0x00,
|
||||
kNewGame = 0x01,
|
||||
kContinue = 0x02,
|
||||
kLoadGame = 0x03,
|
||||
};
|
||||
|
||||
virtual ~MainMenu(); // 00
|
||||
|
||||
// members
|
||||
MAIN_MENU_EXIT_CONDITION mainMenuExitCondition; // 230
|
||||
BSTSet<std::uint32_t> ownedDLC; // 238
|
||||
std::uint64_t creationTime; // 268
|
||||
std::int32_t queuedLoadIndex; // 270
|
||||
bool choseContinue; // 274
|
||||
bool queueStartNewGame; // 275
|
||||
bool queueContinueGame; // 276
|
||||
bool creditScreen; // 277
|
||||
bool userEngaged; // 278
|
||||
bool mainBinkShown; // 279
|
||||
bool allowSkip; // 27A
|
||||
bool debounceMainListPress; // 27B
|
||||
bool nativeConsolePanelIsOpen; // 27C
|
||||
bool shouldDebounceMainListPress; // 27D
|
||||
BSScaleformExternalTexture gamerIconTexture; // 280
|
||||
BSScaleformExternalTexture dlcImageTextures[14]; // 298
|
||||
};
|
||||
static_assert(sizeof(MainMenu) == 0x3E8);
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/M/MARKER_TYPE.h"
|
||||
#include "RE/T/TESFullName.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class __declspec(novtable) MapMarkerData :
|
||||
public TESFullName // 00
|
||||
{
|
||||
const char* GetLocationName()
|
||||
{
|
||||
using func_t = decltype(&MapMarkerData::GetLocationName);
|
||||
static REL::Relocation<func_t> func{ ID::MapMarkerData::GetLocationName };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
std::uint8_t flags; // 10
|
||||
std::uint8_t originalFlags; // 11
|
||||
MARKER_TYPE type; // 12
|
||||
};
|
||||
static_assert(sizeof(MapMarkerData) == 0x18);
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class MarkerIconTypes : std::int32_t
|
||||
{
|
||||
kInvalid = 0x0,
|
||||
kQuest = 0x1,
|
||||
kQuestDoor = 0x2,
|
||||
kPlayerSet = 0x3,
|
||||
kEnemy = 0x4,
|
||||
kLocations = 0x5,
|
||||
kEnemyTargeted = 0x6,
|
||||
kPowerArmor = 0x7,
|
||||
kDogmeat = 0x8,
|
||||
kTeammate = 0x9,
|
||||
kRecon = 0xA
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/H/HeldStateHandler.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MeleeThrowHandler :
|
||||
public HeldStateHandler
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MeleeThrowHandler };
|
||||
static constexpr auto VTABLE{ VTABLE::MeleeThrowHandler };
|
||||
|
||||
// members
|
||||
bool buttonHoldDebounce; // 28
|
||||
bool pressRegistered; // 29
|
||||
bool queueThrow; // 2A
|
||||
};
|
||||
static_assert(sizeof(MeleeThrowHandler) == 0x30);
|
||||
}
|
||||
@@ -0,0 +1,271 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/S/ScrapHeap.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
namespace CompactingStore
|
||||
{
|
||||
class Store;
|
||||
}
|
||||
|
||||
class BSSmallBlockAllocator;
|
||||
class IMemoryHeap;
|
||||
|
||||
class MemoryManager
|
||||
{
|
||||
public:
|
||||
class AutoScrapBuffer
|
||||
{
|
||||
public:
|
||||
AutoScrapBuffer() { ctor(); }
|
||||
~AutoScrapBuffer() { dtor(); }
|
||||
|
||||
[[nodiscard]] void* GetPtr() const noexcept { return ptr; }
|
||||
|
||||
// members
|
||||
void* ptr{ nullptr }; // 0
|
||||
|
||||
private:
|
||||
AutoScrapBuffer* ctor()
|
||||
{
|
||||
using func_t = decltype(&AutoScrapBuffer::ctor);
|
||||
static REL::Relocation<func_t> func{ ID::MemoryManager::AutoScrapBuffer::ctor };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
void dtor()
|
||||
{
|
||||
using func_t = decltype(&AutoScrapBuffer::dtor);
|
||||
static REL::Relocation<func_t> func{ ID::MemoryManager::AutoScrapBuffer::dtor };
|
||||
return func(this);
|
||||
}
|
||||
};
|
||||
static_assert(sizeof(AutoScrapBuffer) == 0x8);
|
||||
|
||||
class ThreadScrapHeap
|
||||
{
|
||||
public:
|
||||
// members
|
||||
ScrapHeap heap; // 00
|
||||
ThreadScrapHeap* next{ nullptr }; // 90
|
||||
std::uint32_t owningThread{ REX::W32::GetCurrentThreadId() }; // 98
|
||||
};
|
||||
static_assert(sizeof(ThreadScrapHeap) == 0xA0);
|
||||
|
||||
[[nodiscard]] static MemoryManager& GetSingleton()
|
||||
{
|
||||
using func_t = decltype(&MemoryManager::GetSingleton);
|
||||
const REL::Relocation<func_t> func{ ID::MemoryManager::Singleton };
|
||||
return func();
|
||||
}
|
||||
|
||||
[[nodiscard]] void* Allocate(std::size_t a_size, std::uint32_t a_alignment, bool a_alignmentRequired)
|
||||
{
|
||||
using func_t = decltype(&MemoryManager::Allocate);
|
||||
const REL::Relocation<func_t> func{ ID::MemoryManager::Allocate };
|
||||
return func(this, a_size, a_alignment, a_alignmentRequired);
|
||||
}
|
||||
|
||||
void Deallocate(void* a_mem, bool a_alignmentRequired)
|
||||
{
|
||||
using func_t = decltype(&MemoryManager::Deallocate);
|
||||
const REL::Relocation<func_t> func{ ID::MemoryManager::Deallocate };
|
||||
return func(this, a_mem, a_alignmentRequired);
|
||||
}
|
||||
|
||||
[[nodiscard]] ScrapHeap* GetThreadScrapHeap()
|
||||
{
|
||||
using func_t = decltype(&MemoryManager::GetThreadScrapHeap);
|
||||
const REL::Relocation<func_t> func{ ID::MemoryManager::GetThreadScrapHeap };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
[[nodiscard]] void* Reallocate(void* a_oldMem, std::size_t a_newSize, std::uint32_t a_alignment, bool a_alignmentRequired)
|
||||
{
|
||||
using func_t = decltype(&MemoryManager::Reallocate);
|
||||
const REL::Relocation<func_t> func{ ID::MemoryManager::Reallocate };
|
||||
return func(this, a_oldMem, a_newSize, a_alignment, a_alignmentRequired);
|
||||
}
|
||||
|
||||
void RegisterMemoryManager()
|
||||
{
|
||||
using func_t = decltype(&MemoryManager::RegisterMemoryManager);
|
||||
const REL::Relocation<func_t> func{ ID::MemoryManager::RegisterMemoryManager };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
// members
|
||||
bool initialized{ false }; // 000
|
||||
std::uint16_t numHeaps{ 0 }; // 002
|
||||
std::uint16_t numPhysicalHeaps{ 0 }; // 004
|
||||
IMemoryHeap** heaps{ nullptr }; // 008
|
||||
bool* allowOtherContextAllocs{ nullptr }; // 010
|
||||
IMemoryHeap* heapsByContext[127]{ nullptr }; // 018
|
||||
ThreadScrapHeap* threadScrapHeap{ nullptr }; // 410
|
||||
IMemoryHeap** physicalHeaps{ nullptr }; // 418
|
||||
IMemoryHeap* bigAllocHeap{ nullptr }; // 420
|
||||
IMemoryHeap* emergencyHeap{ nullptr }; // 428
|
||||
BSSmallBlockAllocator* smallBlockAllocator{ nullptr }; // 430
|
||||
CompactingStore::Store* compactingStore{ nullptr }; // 438
|
||||
IMemoryHeap* externalHavokAllocator{ nullptr }; // 440
|
||||
bool specialHeaps{ false }; // 448
|
||||
bool allowPoolUse{ true }; // 449
|
||||
std::uint32_t sysAllocBytes{ 0 }; // 44C
|
||||
std::uint32_t mallocBytes{ 0 }; // 450
|
||||
std::uint32_t alignmentForPools{ 4 }; // 454
|
||||
std::uint32_t mainThreadMemoryProblemPassSignal{ 0 }; // 458
|
||||
std::size_t failedAllocationSize{ 0 }; // 460
|
||||
std::uint32_t numMemoryProblemPassesRun{ 0 }; // 468
|
||||
std::size_t timeOfLastMemoryProblemPass{ 0 }; // 470
|
||||
IMemoryHeap* defaultHeap{ nullptr }; // 478
|
||||
};
|
||||
static_assert(sizeof(MemoryManager) == 0x480);
|
||||
|
||||
[[nodiscard]] inline void* malloc(std::size_t a_size)
|
||||
{
|
||||
auto& mem = MemoryManager::GetSingleton();
|
||||
return mem.Allocate(a_size, 0, false);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
[[nodiscard]] T* malloc()
|
||||
{
|
||||
return static_cast<T*>(malloc(sizeof(T)));
|
||||
}
|
||||
|
||||
[[nodiscard]] inline void* aligned_alloc(std::size_t a_alignment, std::size_t a_size)
|
||||
{
|
||||
auto& mem = MemoryManager::GetSingleton();
|
||||
return mem.Allocate(a_size, static_cast<std::uint32_t>(a_alignment), true);
|
||||
}
|
||||
|
||||
template <class T>
|
||||
[[nodiscard]] T* aligned_alloc()
|
||||
{
|
||||
return static_cast<T*>(aligned_alloc(alignof(T), sizeof(T)));
|
||||
}
|
||||
|
||||
[[nodiscard]] inline void* calloc(std::size_t a_num, std::size_t a_size)
|
||||
{
|
||||
const auto ret = malloc(a_num * a_size);
|
||||
if (ret) {
|
||||
std::memset(ret, 0, a_num * a_size);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
template <class T>
|
||||
[[nodiscard]] T* calloc(std::size_t a_num)
|
||||
{
|
||||
return static_cast<T*>(calloc(a_num, sizeof(T)));
|
||||
}
|
||||
|
||||
[[nodiscard]] inline void* realloc(void* a_ptr, std::size_t a_newSize)
|
||||
{
|
||||
auto& mem = MemoryManager::GetSingleton();
|
||||
return mem.Reallocate(a_ptr, a_newSize, 0, false);
|
||||
}
|
||||
|
||||
[[nodiscard]] inline void* aligned_realloc(void* a_ptr, std::size_t a_alignment, std::size_t a_newSize)
|
||||
{
|
||||
auto& mem = MemoryManager::GetSingleton();
|
||||
return mem.Reallocate(a_ptr, a_newSize, static_cast<std::uint32_t>(a_alignment), true);
|
||||
}
|
||||
|
||||
inline void free(void* a_ptr)
|
||||
{
|
||||
auto& mem = MemoryManager::GetSingleton();
|
||||
return mem.Deallocate(a_ptr, false);
|
||||
}
|
||||
|
||||
inline void aligned_free(void* a_ptr)
|
||||
{
|
||||
auto& mem = MemoryManager::GetSingleton();
|
||||
return mem.Deallocate(a_ptr, true);
|
||||
}
|
||||
}
|
||||
|
||||
#define F4_HEAP_REDEFINE_HELPER(...) \
|
||||
[[nodiscard]] void* operator new(std::size_t a_count, std::align_val_t a_alignment) \
|
||||
{ \
|
||||
const auto mem = RE::aligned_alloc(static_cast<std::size_t>(a_alignment), a_count); \
|
||||
if (!mem) \
|
||||
REX::FAIL("out of memory"); \
|
||||
\
|
||||
return mem; \
|
||||
} \
|
||||
\
|
||||
[[nodiscard]] void* operator new[](std::size_t a_count, std::align_val_t a_alignment) \
|
||||
{ \
|
||||
const auto mem = RE::aligned_alloc(static_cast<std::size_t>(a_alignment), a_count); \
|
||||
if (!mem) \
|
||||
REX::FAIL("out of memory"); \
|
||||
\
|
||||
return mem; \
|
||||
} \
|
||||
\
|
||||
[[nodiscard]] void* operator new(std::size_t, void* a_ptr) noexcept { return a_ptr; } \
|
||||
[[nodiscard]] void* operator new[](std::size_t, void* a_ptr) noexcept { return a_ptr; } \
|
||||
[[nodiscard]] void* operator new(std::size_t, std::align_val_t, void* a_ptr) noexcept { return a_ptr; } \
|
||||
[[nodiscard]] void* operator new[](std::size_t, std::align_val_t, void* a_ptr) noexcept { return a_ptr; } \
|
||||
\
|
||||
void operator delete(void*, void*) noexcept { return; } \
|
||||
void operator delete[](void*, void*) noexcept { return; } \
|
||||
\
|
||||
void operator delete(void* a_ptr, std::align_val_t) { RE::aligned_free(a_ptr); } \
|
||||
void operator delete[](void* a_ptr, std::align_val_t) { RE::aligned_free(a_ptr); } \
|
||||
void operator delete(void* a_ptr, std::size_t, std::align_val_t) { RE::aligned_free(a_ptr); } \
|
||||
void operator delete[](void* a_ptr, std::size_t, std::align_val_t) { RE::aligned_free(a_ptr); }
|
||||
|
||||
#define F4_HEAP_REDEFINE_NEW(...) \
|
||||
[[nodiscard]] void* operator new(std::size_t a_count) \
|
||||
{ \
|
||||
const auto mem = RE::malloc(a_count); \
|
||||
if (!mem) \
|
||||
REX::FAIL("out of memory"); \
|
||||
\
|
||||
return mem; \
|
||||
} \
|
||||
\
|
||||
[[nodiscard]] void* operator new[](std::size_t a_count) \
|
||||
{ \
|
||||
const auto mem = RE::malloc(a_count); \
|
||||
if (!mem) \
|
||||
REX::FAIL("out of memory"); \
|
||||
\
|
||||
return mem; \
|
||||
} \
|
||||
\
|
||||
void operator delete(void* a_ptr) { RE::free(a_ptr); } \
|
||||
void operator delete[](void* a_ptr) { RE::free(a_ptr); } \
|
||||
void operator delete(void* a_ptr, std::size_t) { RE::free(a_ptr); } \
|
||||
void operator delete[](void* a_ptr, std::size_t) { RE::free(a_ptr); } \
|
||||
\
|
||||
F4_HEAP_REDEFINE_HELPER(__VA_ARGS__)
|
||||
|
||||
#define F4_HEAP_REDEFINE_ALIGNED_NEW(...) \
|
||||
[[nodiscard]] void* operator new(std::size_t a_count) \
|
||||
{ \
|
||||
const auto mem = RE::aligned_alloc(alignof(__VA_ARGS__), a_count); \
|
||||
if (!mem) \
|
||||
REX::FAIL("out of memory"); \
|
||||
\
|
||||
return mem; \
|
||||
} \
|
||||
\
|
||||
[[nodiscard]] void* operator new[](std::size_t a_count) \
|
||||
{ \
|
||||
const auto mem = RE::aligned_alloc(alignof(__VA_ARGS__), a_count); \
|
||||
if (!mem) \
|
||||
REX::FAIL("out of memory"); \
|
||||
\
|
||||
return mem; \
|
||||
} \
|
||||
\
|
||||
void operator delete(void* a_ptr) { RE::aligned_free(a_ptr); } \
|
||||
void operator delete[](void* a_ptr) { RE::aligned_free(a_ptr); } \
|
||||
void operator delete(void* a_ptr, std::size_t) { RE::aligned_free(a_ptr); } \
|
||||
void operator delete[](void* a_ptr, std::size_t) { RE::aligned_free(a_ptr); } \
|
||||
\
|
||||
F4_HEAP_REDEFINE_HELPER(__VA_ARGS__)
|
||||
@@ -0,0 +1,51 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSInputEventReceiver.h"
|
||||
#include "RE/B/BSTArray.h"
|
||||
#include "RE/B/BSTSingleton.h"
|
||||
#include "RE/S/ScreenshotHandler.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class BSInputEventUser;
|
||||
class CameraZoomHandler;
|
||||
class ClickHandler;
|
||||
class DisconnectHandler;
|
||||
class GFxConvertHandler;
|
||||
class MenuOpenHandler;
|
||||
class PipboyHandler;
|
||||
class QuickSaveLoadHandler;
|
||||
|
||||
class MenuControls :
|
||||
public BSInputEventReceiver, // 00
|
||||
public BSTSingletonSDM<MenuControls> // 10
|
||||
{
|
||||
public:
|
||||
[[nodiscard]] static MenuControls* GetSingleton()
|
||||
{
|
||||
static REL::Relocation<MenuControls**> singleton{ ID::MenuControls::Singleton };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
bool QueueScreenshot() const
|
||||
{
|
||||
if (!screenshotHandler || screenshotHandler->screenshotQueued) {
|
||||
return false;
|
||||
}
|
||||
screenshotHandler->screenshotQueued = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
// members
|
||||
BSTArray<BSInputEventUser*> handlers; // 18
|
||||
GFxConvertHandler* convertHandler; // 30
|
||||
DisconnectHandler* disconnectHandler; // 38
|
||||
ClickHandler* clickHandler; // 40
|
||||
QuickSaveLoadHandler* quickSaveLoadHandler; // 48
|
||||
MenuOpenHandler* menuOpenHandler; // 50
|
||||
ScreenshotHandler* screenshotHandler; // 58
|
||||
CameraZoomHandler* cameraZoomHandler; // 60
|
||||
PipboyHandler* pipboyHandler; // 68
|
||||
};
|
||||
static_assert(sizeof(MenuControls) == 0x70);
|
||||
}
|
||||
@@ -0,0 +1,78 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSInputEventSingleUser.h"
|
||||
#include "RE/B/BSTSingleton.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class __declspec(novtable) MenuCursor :
|
||||
public BSInputEventSingleUser, // 00
|
||||
public BSTSingletonSDM<MenuCursor> // 20
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MenuCursor };
|
||||
static constexpr auto VTABLE{ VTABLE::MenuCursor };
|
||||
|
||||
[[nodiscard]] static MenuCursor* GetSingleton()
|
||||
{
|
||||
static REL::Relocation<MenuCursor**> singleton{ ID::MenuCursor::Singleton };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
void CenterCursor()
|
||||
{
|
||||
using func_t = decltype(&MenuCursor::CenterCursor);
|
||||
static REL::Relocation<func_t> func{ ID::MenuCursor::CenterCursor };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
void ClearConstraints() noexcept
|
||||
{
|
||||
leftConstraintPct = 0.0f;
|
||||
rightConstraintPct = 0.0f;
|
||||
topConstraintPct = 0.0f;
|
||||
bottomConstraintPct = 0.0f;
|
||||
}
|
||||
|
||||
void ConstrainForPipboy();
|
||||
void ConstrainForPipboyPA();
|
||||
|
||||
void RegisterCursor()
|
||||
{
|
||||
using func_t = decltype(&MenuCursor::RegisterCursor);
|
||||
static REL::Relocation<func_t> func{ ID::MenuCursor::RegisterCursor };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
void SetCursorConstraintsRaw(std::uint32_t a_tlx, std::uint32_t a_tly, std::uint32_t a_width, std::uint32_t a_height)
|
||||
{
|
||||
using func_t = decltype(&MenuCursor::SetCursorConstraintsRaw);
|
||||
static REL::Relocation<func_t> func{ ID::MenuCursor::SetCursorConstraintsRaw };
|
||||
return func(this, a_tlx, a_tly, a_width, a_height);
|
||||
}
|
||||
|
||||
void UnregisterCursor()
|
||||
{
|
||||
using func_t = decltype(&MenuCursor::UnregisterCursor);
|
||||
static REL::Relocation<func_t> func{ ID::MenuCursor::UnregisterCursor };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
// members
|
||||
std::int32_t cursorPosX; // 24
|
||||
std::int32_t cursorPosY; // 28
|
||||
std::int32_t minCursorX; // 2C
|
||||
std::int32_t minCursorY; // 30
|
||||
std::int32_t maxCursorX; // 34
|
||||
std::int32_t maxCursorY; // 38
|
||||
float leftConstraintPct; // 3C
|
||||
float rightConstraintPct; // 40
|
||||
float topConstraintPct; // 44
|
||||
float bottomConstraintPct; // 48
|
||||
float gamepadCursorSpeed; // 4C
|
||||
std::uint32_t registeredCursors; // 50
|
||||
bool forceOSCursorPos; // 54
|
||||
bool allowGamepadCursorOverride; // 55
|
||||
};
|
||||
static_assert(sizeof(MenuCursor) == 0x58);
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSFixedString.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MenuModeChangeEvent
|
||||
{
|
||||
public:
|
||||
// members
|
||||
BSFixedString menuName; // 00
|
||||
bool enteringMenuMode; // 08
|
||||
};
|
||||
static_assert(sizeof(MenuModeChangeEvent) == 0x10);
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSFixedString.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MenuModeCounterChangedEvent
|
||||
{
|
||||
public:
|
||||
// members
|
||||
BSFixedString menuName; // 00
|
||||
bool incrementing; // 08
|
||||
};
|
||||
static_assert(sizeof(MenuModeCounterChangedEvent) == 0x10);
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSFixedString.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MenuOpenCloseEvent
|
||||
{
|
||||
public:
|
||||
// members
|
||||
BSFixedString menuName; // 00
|
||||
bool opening; // 08
|
||||
};
|
||||
static_assert(sizeof(MenuOpenCloseEvent) == 0x10);
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSInputEventUser.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class __declspec(novtable) MenuOpenHandler :
|
||||
public BSInputEventUser // 00
|
||||
{
|
||||
static constexpr auto RTTI{ RTTI::MenuOpenHandler };
|
||||
static constexpr auto VTABLE{ VTABLE::MenuOpenHandler };
|
||||
};
|
||||
static_assert(sizeof(MenuOpenHandler) == 0x10);
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSPointerHandle.h"
|
||||
#include "RE/B/BSTEvent.h"
|
||||
#include "RE/B/BSTSingleton.h"
|
||||
#include "RE/B/BSTSmartPointer.h"
|
||||
#include "RE/N/NiPoint3.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class BSInputEnableLayer;
|
||||
class MenuOpenCloseEvent;
|
||||
class PositionPlayerEvent;
|
||||
|
||||
class __declspec(novtable) MenuTopicManager :
|
||||
public BSTEventSink<MenuOpenCloseEvent>, // 00
|
||||
public BSTEventSink<PositionPlayerEvent>, // 08
|
||||
public BSTSingletonSDM<MenuTopicManager> // 10
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MenuTopicManager };
|
||||
static constexpr auto VTABLE{ VTABLE::MenuTopicManager };
|
||||
|
||||
[[nodiscard]] static MenuTopicManager* GetSingleton()
|
||||
{
|
||||
static REL::Relocation<MenuTopicManager**> singleton{ ID::MenuTopicManager::Singleton };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
bool IsCurrentSpeaker(const ObjectRefHandle& a_handle) const
|
||||
{
|
||||
return menuOpen && speaker == a_handle;
|
||||
}
|
||||
|
||||
// members
|
||||
ObjectRefHandle speaker; // 14
|
||||
ObjectRefHandle lastSpeaker; // 18
|
||||
BSTSmartPointer<BSInputEnableLayer> inputLayer; // 20
|
||||
float reLookTimer; // 28
|
||||
float notInMenuTimer; // 2C
|
||||
float restartMenuOnFocus; // 30
|
||||
float menuStart; // 34
|
||||
float buttonShowTimer; // 38
|
||||
NiPoint3 centerPoint; // 3C
|
||||
uint32_t numRefsInScene; // 48
|
||||
bool menuOpen; // 4C
|
||||
bool shutMenu; // 4D
|
||||
bool canSkip; // 4E
|
||||
bool shuttingDown; // 4F
|
||||
bool menuSlow; // 50
|
||||
bool doneFOV; // 51
|
||||
bool leaveMenuOpen; // 52
|
||||
bool showHelpButton; // 53
|
||||
bool needEnterDialogueAction; // 54
|
||||
bool allowInput; // 55
|
||||
bool thirdPartyCameraReady; // 56
|
||||
bool speechChallengeAlwaysSucceed; // 57
|
||||
bool speechChallengeAlwaysFail; // 58
|
||||
bool overSceneActor; // 59
|
||||
bool forceCameraRotationStart; // 5A
|
||||
};
|
||||
static_assert(sizeof(MenuTopicManager) == 0x60);
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSStringT.h"
|
||||
#include "RE/B/BSTArray.h"
|
||||
#include "RE/B/BSTSmartPointer.h"
|
||||
#include "RE/I/IUIMessageData.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class UI_DEPTH_PRIORITY;
|
||||
enum class WARNING_TYPES;
|
||||
class IMessageBoxCallback;
|
||||
|
||||
class __declspec(novtable) MessageBoxData :
|
||||
public IUIMessageData // 00
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MessageBoxData };
|
||||
static constexpr auto VTABLE{ VTABLE::MessageBoxData };
|
||||
|
||||
// members
|
||||
BSString headerText; // 18
|
||||
BSString bodyText; // 28
|
||||
BSTArray<BSString> buttonText; // 38
|
||||
REX::TEnumSet<WARNING_TYPES, std::uint32_t> warningContext; // 50
|
||||
BSTSmartPointer<IMessageBoxCallback> callback; // 58
|
||||
REX::TEnumSet<UI_DEPTH_PRIORITY, std::uint32_t> menuDepth; // 60
|
||||
bool modal; // 64
|
||||
bool ensureUnique; // 65
|
||||
};
|
||||
static_assert(sizeof(MessageBoxData) == 0x68);
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSTEvent.h"
|
||||
#include "RE/G/GameMenuBase.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MenuModeChangeEvent;
|
||||
class MessageBoxData;
|
||||
|
||||
class __declspec(novtable) MessageBoxMenu :
|
||||
public GameMenuBase, // 00
|
||||
public BSTEventSink<MenuModeChangeEvent> // E0
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MessageBoxMenu };
|
||||
static constexpr auto VTABLE{ VTABLE::MessageBoxMenu };
|
||||
static constexpr auto MENU_NAME{ "MessageBoxMenu"sv };
|
||||
|
||||
// override
|
||||
virtual void Call(const Params&) override; // 01
|
||||
virtual void MapCodeObjectFunctions() override; // 02
|
||||
virtual UI_MESSAGE_RESULTS ProcessMessage(UIMessage&) override; // 03
|
||||
|
||||
void ShowMessage()
|
||||
{
|
||||
using func_t = decltype(&MessageBoxMenu::ShowMessage);
|
||||
static REL::Relocation<func_t> func{ ID::MessageBoxMenu::ShowMessage };
|
||||
return func(this);
|
||||
}
|
||||
|
||||
// members
|
||||
MessageBoxData* currentMessage; // E8
|
||||
};
|
||||
static_assert(sizeof(MessageBoxMenu) == 0xF0);
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSSpinLock.h"
|
||||
#include "RE/B/BSTArray.h"
|
||||
#include "RE/B/BSTSingleton.h"
|
||||
#include "RE/M/MessageBoxData.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MessageMenuManager :
|
||||
public BSTSingletonSDM<MessageMenuManager> // 00
|
||||
{
|
||||
public:
|
||||
[[nodiscard]] static MessageMenuManager* GetSingleton()
|
||||
{
|
||||
static REL::Relocation<MessageMenuManager**> singleton{ ID::MessageMenuManager::Singleton };
|
||||
return *singleton;
|
||||
}
|
||||
|
||||
void Create(
|
||||
const char* a_headerText,
|
||||
const char* a_bodyText,
|
||||
IMessageBoxCallback* a_callback,
|
||||
WARNING_TYPES a_warningContext,
|
||||
const char* a_button1Text = nullptr,
|
||||
const char* a_button2Text = nullptr,
|
||||
const char* a_button3Text = nullptr,
|
||||
const char* a_button4Text = nullptr,
|
||||
bool a_ensureUnique = false)
|
||||
{
|
||||
using func_t = decltype(&MessageMenuManager::Create);
|
||||
static REL::Relocation<func_t> func{ ID::MessageMenuManager::Create };
|
||||
return func(this, a_headerText, a_bodyText, a_callback, a_warningContext, a_button1Text, a_button2Text, a_button3Text, a_button4Text, a_ensureUnique);
|
||||
}
|
||||
|
||||
// members
|
||||
BSReadWriteLock messageRWLock; // 04
|
||||
BSTArray<MessageBoxData*> messages; // 10
|
||||
REX::TEnumSet<WARNING_TYPES, std::uint32_t> currentWarningContext; // 28
|
||||
bool disabledWarnings[34]; // 2C
|
||||
};
|
||||
static_assert(sizeof(MessageMenuManager) == 0x50);
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/A/AITimeStamp.h"
|
||||
#include "RE/A/ActiveEffectList.h"
|
||||
#include "RE/A/ActorPackage.h"
|
||||
#include "RE/B/BSFixedString.h"
|
||||
#include "RE/B/BSPointerHandle.h"
|
||||
#include "RE/B/BSSimpleList.h"
|
||||
#include "RE/B/BSSpinLock.h"
|
||||
#include "RE/B/BSTArray.h"
|
||||
#include "RE/B/BSTEvent.h"
|
||||
#include "RE/B/BSTSmartPointer.h"
|
||||
#include "RE/B/BSTTuple.h"
|
||||
#include "RE/N/NiPoint3.h"
|
||||
#include "RE/N/NiPointer.h"
|
||||
#include "RE/S/SubgraphHandle.h"
|
||||
#include "RE/S/SubgraphIdentifier.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class PACKAGE_OBJECT_TYPE;
|
||||
class ActorInventoryEvent;
|
||||
class AIPerkData;
|
||||
class bhkCharacterController;
|
||||
class bhkNPCollisionObject;
|
||||
class bhkRagdollPenetrationUtil;
|
||||
class BSAnimationGraphManager;
|
||||
class BSAnimationGraphVariableCache;
|
||||
class BSClothExtraData;
|
||||
class BSFaceGenAnimationData;
|
||||
class BSFaceGenNiNode;
|
||||
class BSLightingShaderProperty;
|
||||
class CommandedActorData;
|
||||
class DeferredHideLimb;
|
||||
class EquippedItem;
|
||||
class HitData;
|
||||
class IAnimationStanceData;
|
||||
class NiAVObject;
|
||||
class NiNode;
|
||||
class QueuedFile;
|
||||
class QueuedItem;
|
||||
class SubGraphIdleRootData;
|
||||
|
||||
namespace MagicSystem
|
||||
{
|
||||
enum class WardState;
|
||||
}
|
||||
|
||||
class MiddleHighProcessData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
BSTEventSource<ActorInventoryEvent> inventoryEventSource; // 000
|
||||
NiPointer<bhkNPCollisionObject> poseBound; // 058
|
||||
ActorPackage runOncePackage; // 060
|
||||
BSTArray<ActorHandle> deadDetectList; // 090
|
||||
BSSimpleList<TESObjectREFR*> refListChairBed; // 0A8
|
||||
NiPoint3 rotation; // 0B8
|
||||
NiPoint3 rotationSpeed; // 0C4
|
||||
NiPoint3 actorMountPosition; // 0D0
|
||||
NiPoint3 furniturePathPoint; // 0DC
|
||||
NiPoint3 lastSeenPosition; // 0E8
|
||||
ActorHandle bleedoutAttacker; // 0F4
|
||||
REX::TEnumSet<MagicSystem::WardState, std::int32_t> wardState; // 0F8
|
||||
BSTSmartPointer<void*> animResponse; // 100 - BSResponse<BSFixedString, Actor, BSFixedString, DoNothingUnhandledPolicy>
|
||||
BSTArray<CommandedActorData> commandedActors; // 108
|
||||
NiNode* damageRootNode[26]; // 120
|
||||
NiNode* weaponBone; // 1F0
|
||||
NiAVObject* headNode; // 1F8
|
||||
NiAVObject* torsoNode; // 200
|
||||
NiAVObject* faceTargetSourceNode; // 208
|
||||
BSFaceGenNiNode* faceNodeSkinned; // 210
|
||||
NiPointer<BSLightingShaderProperty> lightingProperty; // 218
|
||||
QueuedItem* listItemstoEquipUnequip; // 220
|
||||
HitData* lastHitData; // 228
|
||||
DeferredHideLimb* headDeferredHideLimb; // 230
|
||||
ActiveEffectList activeEffects; // 238
|
||||
BSTSmartPointer<BSAnimationGraphManager> animationGraphManager; // 258
|
||||
BSAnimationGraphVariableCache* animationVariableCache; // 260
|
||||
BSTArray<SubGraphIdleRootData> subGraphIdleManagerRoots; // 268
|
||||
BSSpinLock equippedItemsLock; // 280
|
||||
BSTArray<EquippedItem> equippedItems; // 288
|
||||
BSTArray<BSClothExtraData*> clothExtraDataCache; // 2A0
|
||||
BSTArray<BSTSmallArray<SubgraphHandle, 2>> subGraphHandles; // 2B8
|
||||
BSTSmallArray<SubgraphIdentifier, 2> currentDefaultSubGraphID; // 2D0
|
||||
BSTSmallArray<SubgraphIdentifier, 2> requestedDefaultSubGraphID; // 2F0
|
||||
BSTSmallArray<SubgraphIdentifier, 2> currentWeaponSubGraphID; // 310
|
||||
BSTSmallArray<SubgraphIdentifier, 2> requestedWeaponSubGraphID; // 330
|
||||
BSTSmartPointer<IAnimationStanceData> stanceData; // 350
|
||||
BSTArray<BSTTuple<std::uint32_t, void*>> nodeLocationArray; // 358 - AnimationStanceNodeLocationData<NiPoint3>
|
||||
float stanceHeightArray[6][2]; // 370
|
||||
float headHeightOffset; // 3A0
|
||||
ObjectRefHandle currentFurniture; // 3A4
|
||||
ObjectRefHandle occupiedFurniture; // 3A8
|
||||
TESIdleForm* currentIdle; // 3B0
|
||||
ActorHandle commandingActor; // 3B8
|
||||
const TESIdleForm* furnitureIdle; // 3C0
|
||||
BSFaceGenAnimationData* faceAnimationData; // 3C8
|
||||
MagicItem* currentPackageSpell; // 3D0
|
||||
TESObjectWEAP* lastBoundWeapon; // 3D8
|
||||
NiPointer<bhkCharacterController> charController; // 3E0
|
||||
BSTSmartPointer<bhkRagdollPenetrationUtil> penetrationDetectUtil; // 3E8
|
||||
NiPointer<QueuedFile> bodyPartPreload; // 3F0
|
||||
TESIdleForm* lastIdlePlayed; // 3F8
|
||||
AIPerkData* perkData; // 400
|
||||
NiPoint3 lookAtLocation; // 408
|
||||
float pursueTimer; // 414
|
||||
float furnitureAngle; // 418
|
||||
float furnitureEntryFootstepDeltaTarget; // 41C
|
||||
float packageIdleTimer; // 420
|
||||
float equippedWeight; // 424
|
||||
float desiredSpeed; // 428
|
||||
float animationSpeed; // 42C
|
||||
float bleedoutTimer; // 430
|
||||
float bleedoutRate; // 434
|
||||
float bleedoutMaxHealth; // 438
|
||||
float maxWardPower; // 43C
|
||||
float animGraphEventTimeout; // 440
|
||||
float torchEvalTimer; // 444
|
||||
float alphaMult; // 448
|
||||
float scriptRefractPower; // 44C
|
||||
float sleepingTimer; // 450
|
||||
float deferredKillTimer; // 454
|
||||
float killMoveTimer; // 458
|
||||
float staggerTimer; // 45C
|
||||
float mountDismountSafetyTimer; // 460
|
||||
AITimeStamp rangeWaypointIdleTimer; // 464
|
||||
std::int32_t packageIdleNumber; // 468
|
||||
std::int32_t reservationSlot; // 46C
|
||||
SubgraphIdentifier currentFurnitureSubgraphID; // 470
|
||||
std::uint32_t currentFurnitureMarkerID; // 478
|
||||
std::uint32_t occupiedFurnitureMarkerID; // 47C
|
||||
std::uint64_t nextExtraArrow3DUpdate; // 480
|
||||
std::uint32_t deferredKill; // 488
|
||||
std::uint32_t flareFlags; // 48C
|
||||
REX::TEnumSet<PACKAGE_OBJECT_TYPE, std::int32_t> useItem; // 490
|
||||
std::int16_t animActionSuccess; // 494
|
||||
std::uint16_t update3DModel; // 496
|
||||
std::int8_t weaponCullCounter; // 498
|
||||
std::int8_t archetypeChangeType; // 499
|
||||
bool animWeaponCull; // 49A
|
||||
bool aimingTarget; // 49B
|
||||
bool doneClothesChange; // 49C
|
||||
bool pickPackIdle; // 49D
|
||||
bool doneOnce; // 49E
|
||||
bool refreshFlareFlags; // 49F
|
||||
bool pickPocketed; // 4A0
|
||||
bool summonedCreature; // 4A1
|
||||
bool forceNextUpdate; // 4A2
|
||||
bool playedBeginIdles; // 4A3
|
||||
bool playedEndIdles; // 4A4
|
||||
bool quickPlacement; // 4A5
|
||||
bool beenAttacked; // 4A6
|
||||
bool alwaysHit; // 4A7
|
||||
bool doNoDamage; // 4A8
|
||||
bool soulTrapped; // 4A9
|
||||
bool lookAt; // 4AA
|
||||
bool eating; // 4AB
|
||||
bool calcLight; // 4AC
|
||||
bool preventCombat; // 4AD
|
||||
bool dyingFromBleedout; // 4AE
|
||||
bool fleeing; // 4AF
|
||||
bool instantGetOut; // 4B0
|
||||
bool hostileGuard; // 4B1
|
||||
bool stopIdleFailed; // 4B2
|
||||
bool killQueued; // 4B3
|
||||
bool ragdollInstant; // 4B4
|
||||
bool scriptDeferredKill; // 4B5
|
||||
bool furnitureEntryLeftFootFirst; // 4B6
|
||||
bool furnitureAnimationPlayed; // 4B7
|
||||
bool queuedInstantInteractionAnimation; // 4B8
|
||||
bool queuedModifyInitialAnimationPose; // 4B9
|
||||
bool avoidPlayer; // 4BA
|
||||
bool usingPathingFaceTargetWhileTrackingOutOfRange; // 4BB
|
||||
};
|
||||
static_assert(sizeof(MiddleHighProcessData) == 0x4C0);
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MiddleLowProcessData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
std::int32_t hourPackageEvaluated; // 0
|
||||
};
|
||||
static_assert(sizeof(MiddleLowProcessData) == 0x4);
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiMatrix3.h"
|
||||
#include "RE/N/NiPoint3.h"
|
||||
#include "RE/N/NiPointer.h"
|
||||
#include "RE/P/Projectile.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
enum class ImpactResult;
|
||||
class bhkNPCollisionObject;
|
||||
|
||||
class __declspec(novtable) MissileProjectile :
|
||||
public Projectile // 000
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MissileProjectile };
|
||||
static constexpr auto VTABLE{ VTABLE::MissileProjectile };
|
||||
static constexpr auto FORM_ID{ ENUM_FORM_ID::kPMIS };
|
||||
|
||||
// add
|
||||
virtual bool ShouldReorient() const; // EA
|
||||
|
||||
// members
|
||||
NiMatrix3 dismemberedLimbRotation; // 270
|
||||
NiPoint3 dismemberedLimbOffset; // 2A0
|
||||
NiPointer<bhkNPCollisionObject> modelCollision; // 2B0
|
||||
REX::TEnumSet<ImpactResult, std::int32_t> impactResult; // 2B8
|
||||
bool waitingToInitialize3D; // 2BC
|
||||
bool deferProcessImpale; // 2BD
|
||||
};
|
||||
static_assert(sizeof(MissileProjectile) == 0x2C0);
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/E/ExamineConfirmMenu.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class __declspec(novtable) ModConfirmCallback :
|
||||
public ExamineConfirmMenu::ICallback // 00
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::__ModConfirmCallback };
|
||||
static constexpr auto VTABLE{ VTABLE::__ModConfirmCallback };
|
||||
|
||||
ModConfirmCallback(ExamineMenu* a_thisMenu) :
|
||||
ExamineConfirmMenu::ICallback(a_thisMenu)
|
||||
{
|
||||
REX::EMPLACE_VTABLE(this);
|
||||
}
|
||||
|
||||
virtual ~ModConfirmCallback() = default; // 00
|
||||
|
||||
// override
|
||||
virtual void OnAccept() override; // 01
|
||||
|
||||
F4_HEAP_REDEFINE_NEW(ModConfirmCallback);
|
||||
};
|
||||
static_assert(sizeof(ModConfirmCallback) == 0x10);
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSTEvent.h"
|
||||
#include "RE/N/NiPointer.h"
|
||||
#include "RE/R/RefAttachTechniqueInput.h"
|
||||
#include "RE/R/ReferenceEffect.h"
|
||||
#include "RE/S/SimpleAnimationGraphManagerHolder.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class BGSArtObjectCloneTask;
|
||||
class NiAVObject;
|
||||
class BSAnimationGraphEvent;
|
||||
|
||||
class __declspec(novtable) ModelReferenceEffect :
|
||||
public ReferenceEffect, // 00
|
||||
public SimpleAnimationGraphManagerHolder, // 48
|
||||
public BSTEventSink<BSAnimationGraphEvent> // 60
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::ModelReferenceEffect };
|
||||
static constexpr auto VTABLE{ VTABLE::ModelReferenceEffect };
|
||||
static constexpr auto Ni_RTTI{ Ni_RTTI::ModelReferenceEffect };
|
||||
static constexpr auto TYPE{ TEMP_EFFECT_TYPE::kRefModel };
|
||||
|
||||
~ModelReferenceEffect() override;
|
||||
|
||||
// members
|
||||
RefAttachTechniqueInput hitEffectArtData; // 70
|
||||
void* loadedDataSubBuffer; // B8
|
||||
BGSArtObject* artObject; // C0
|
||||
NiPointer<BGSArtObjectCloneTask> cloneTask; // C8
|
||||
NiPointer<NiAVObject> artObject3D; // D0
|
||||
std::uint32_t flags; // D4
|
||||
};
|
||||
static_assert(sizeof(ModelReferenceEffect) == 0xD8);
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
#pragma once
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class Modifiers
|
||||
{
|
||||
public:
|
||||
// members
|
||||
float modifiers[3]; // 0
|
||||
};
|
||||
static_assert(sizeof(Modifiers) == 0xC);
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiBillboardNode.h"
|
||||
#include "RE/S/SkyObject.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class __declspec(novtable) alignas(0x08) Moon :
|
||||
public SkyObject // 00
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::Moon };
|
||||
static constexpr auto VTABLE{ VTABLE::Moon };
|
||||
|
||||
virtual ~Moon();
|
||||
|
||||
enum class Phase
|
||||
{
|
||||
kFull = 0x0,
|
||||
k3QWan = 0x1,
|
||||
kHalfWan = 0x2,
|
||||
k1QWan = 0x3,
|
||||
kNew = 0x4,
|
||||
k1QWax = 0x5,
|
||||
kHalfWax = 0x6,
|
||||
k3QWax = 0x7
|
||||
};
|
||||
|
||||
enum class UpdateStatus
|
||||
{
|
||||
kNotRequired = 0x0,
|
||||
kWhenCulled = 0x1,
|
||||
kInitialize = 0x2
|
||||
};
|
||||
|
||||
// members
|
||||
NiPointer<NiBillboardNode> moonBaseNode; // 10
|
||||
NiPointer<NiNode> moonNode; // 18
|
||||
NiPointer<NiNode> shadowNode; // 20
|
||||
NiPointer<BSTriShape> moonMesh; // 28
|
||||
NiPointer<BSTriShape> shadowMesh; // 30
|
||||
BSString textures[8]; // 38
|
||||
float angleFadeStart; // B8
|
||||
float angleFadeEnd; // BC
|
||||
float angleShadowEarlyFade; // C0
|
||||
float speed; // C4
|
||||
float zOffset; // C8
|
||||
std::uint32_t size; // CC
|
||||
UpdateStatus updateMoonTexture; // D0
|
||||
};
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/I/IDEvent.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class __declspec(novtable) MouseMoveEvent :
|
||||
public IDEvent // 00
|
||||
{
|
||||
public:
|
||||
static constexpr auto RTTI{ RTTI::MouseMoveEvent };
|
||||
static constexpr auto VTABLE{ VTABLE::MouseMoveEvent };
|
||||
static constexpr auto TYPE{ INPUT_EVENT_TYPE::kMouseMove };
|
||||
|
||||
// NOLINTNEXTLINE(modernize-use-override)
|
||||
virtual ~MouseMoveEvent() = default; // 00
|
||||
|
||||
// members
|
||||
std::int32_t mouseInputX{ 0 }; // 38
|
||||
std::int32_t mouseInputY{ 0 }; // 3C
|
||||
};
|
||||
static_assert(sizeof(MouseMoveEvent) == 0x40);
|
||||
|
||||
extern template MouseMoveEvent* InputEvent::As() noexcept;
|
||||
extern template const MouseMoveEvent* InputEvent::As() const noexcept;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiPoint3.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);
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSFixedString.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
namespace Movement
|
||||
{
|
||||
enum class SPEED_DIRECTION
|
||||
{
|
||||
kTranslation = 0x0,
|
||||
kLeft = 0x0,
|
||||
kRight = 0x1,
|
||||
kForward = 0x2,
|
||||
kBack = 0x3,
|
||||
kRotations = 0x4,
|
||||
kPitch = 0x4,
|
||||
kRoll = 0x5,
|
||||
kYaw = 0x6,
|
||||
kCount = 0x7
|
||||
};
|
||||
|
||||
class MaxSpeeds
|
||||
{
|
||||
public:
|
||||
// members
|
||||
float speeds[7][4]; // 00
|
||||
};
|
||||
static_assert(sizeof(MaxSpeeds) == 0x70);
|
||||
|
||||
class TypeData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
BSFixedString typeName; // 00
|
||||
MaxSpeeds defaultData; // 08
|
||||
float floatHeight; // 78
|
||||
float flightAngleGain; // 7C
|
||||
};
|
||||
static_assert(sizeof(TypeData) == 0x80);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiPoint3.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);
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiPoint3.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);
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiPoint3.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MovementData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
NiPoint3A movementRotation; // 00
|
||||
NiPoint3A rotationSpeed; // 10
|
||||
float movementSpeed; // 20
|
||||
};
|
||||
static_assert(sizeof(MovementData) == 0x30);
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/B/BSFixedString.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
namespace MovementLargeDelta
|
||||
{
|
||||
enum class SPEED;
|
||||
|
||||
enum class FROM_DIRECTION
|
||||
{
|
||||
kFacingForward = 0,
|
||||
kStrafingRight = 1,
|
||||
kStrafingBackward = 2,
|
||||
kStrafingLeft = 3,
|
||||
|
||||
kTotal = 4,
|
||||
};
|
||||
|
||||
enum class TO_DIRECTION
|
||||
{
|
||||
kFacingForward = 0,
|
||||
kStrafingRight = 1,
|
||||
kStrafingBackward = 2,
|
||||
kStrafingLeft = 3,
|
||||
kFacingRight = 4,
|
||||
kFacingBackward = 5,
|
||||
kFacingLeft = 6,
|
||||
|
||||
kTotal = 0x7,
|
||||
};
|
||||
|
||||
class CurrentState
|
||||
{
|
||||
public:
|
||||
// members
|
||||
REX::TEnumSet<SPEED, std::uint32_t> fromSpeed; // 00
|
||||
REX::TEnumSet<FROM_DIRECTION, std::uint32_t> fromDirection; // 04
|
||||
};
|
||||
static_assert(sizeof(CurrentState) == 0x8);
|
||||
|
||||
class DesiredState
|
||||
{
|
||||
public:
|
||||
// members
|
||||
REX::TEnum<SPEED, std::uint32_t> toSpeed;
|
||||
REX::TEnum<TO_DIRECTION, std::uint32_t> toDirection;
|
||||
};
|
||||
static_assert(sizeof(DesiredState) == 0x8);
|
||||
|
||||
class IdleSelectionData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
CurrentState fromState; // 00
|
||||
DesiredState toState; // 08
|
||||
};
|
||||
static_assert(sizeof(IdleSelectionData) == 0x10);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiPoint3.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MovementTweenerOutputData
|
||||
{
|
||||
public:
|
||||
// members
|
||||
NiPoint3 velocity; // 00
|
||||
NiPoint3 rotationSpeed; // 0C
|
||||
};
|
||||
static_assert(sizeof(MovementTweenerOutputData) == 0x18);
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
#pragma once
|
||||
|
||||
#include "RE/N/NiPoint3.h"
|
||||
|
||||
namespace RE
|
||||
{
|
||||
class MovementVector
|
||||
{
|
||||
public:
|
||||
// members
|
||||
NiPoint3A eulerAngles; // 00
|
||||
float speed; // 10
|
||||
};
|
||||
static_assert(sizeof(MovementVector) == 0x20);
|
||||
}
|
||||
Reference in New Issue
Block a user