From 94c27dacd6dc16d304ef38dce74b012f50c09598 Mon Sep 17 00:00:00 2001 From: Qudix <17361645+Qudix@users.noreply.github.com> Date: Tue, 28 May 2024 01:57:21 -0500 Subject: [PATCH 1/5] build: improve `xmake` --- AddressLibDecoder/xmake.lua | 4 ++-- AddressLibGen/xmake.lua | 4 ++-- CommonLibF4/xmake.lua | 3 +++ RTTIDump/xmake.lua | 4 ++-- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/AddressLibDecoder/xmake.lua b/AddressLibDecoder/xmake.lua index 70b49b75..5cfe4090 100644 --- a/AddressLibDecoder/xmake.lua +++ b/AddressLibDecoder/xmake.lua @@ -1,9 +1,9 @@ -target("addresslibdecoder") +target("commonlibf4-addresslibdecoder") -- set build by default set_default(false) -- set build group - set_group("tool") + set_group("commonlibf4/tool") -- add packages add_packages("rsm-mmio") diff --git a/AddressLibGen/xmake.lua b/AddressLibGen/xmake.lua index d1aab293..1f7bb409 100644 --- a/AddressLibGen/xmake.lua +++ b/AddressLibGen/xmake.lua @@ -1,9 +1,9 @@ -target("addresslibgen") +target("commonlibf4-addresslibgen") -- set build by default set_default(false) -- set build group - set_group("tool") + set_group("commonlibf4/tool") -- add source files add_files("src/**.cpp") diff --git a/CommonLibF4/xmake.lua b/CommonLibF4/xmake.lua index 6b663d4a..af90b687 100644 --- a/CommonLibF4/xmake.lua +++ b/CommonLibF4/xmake.lua @@ -9,6 +9,9 @@ end) target("commonlibf4", function() set_kind("static") + -- set build group + set_group("commonlibf4") + -- add packages add_packages("rsm-binary-io", "rsm-mmio", "spdlog", { public = true }) diff --git a/RTTIDump/xmake.lua b/RTTIDump/xmake.lua index 8ef2e6fd..26064ea0 100644 --- a/RTTIDump/xmake.lua +++ b/RTTIDump/xmake.lua @@ -1,4 +1,4 @@ -target("rttidump") +target("commonlibf4-rttidump") -- set build kind set_kind("shared") @@ -6,7 +6,7 @@ target("rttidump") set_default(false) -- set build group - set_group("plugin") + set_group("commonlibf4/plugin") -- add dependencies add_deps("commonlibf4") From 4f9be70ad5698eb568a26003aaf98a3359785e02 Mon Sep 17 00:00:00 2001 From: Qudix <17361645+Qudix@users.noreply.github.com> Date: Tue, 28 May 2024 09:38:49 -0500 Subject: [PATCH 2/5] fix: unreachable warning --- CommonLibF4/src/RE/Bethesda/FormComponents.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/CommonLibF4/src/RE/Bethesda/FormComponents.cpp b/CommonLibF4/src/RE/Bethesda/FormComponents.cpp index f198f1de..93aebec7 100644 --- a/CommonLibF4/src/RE/Bethesda/FormComponents.cpp +++ b/CommonLibF4/src/RE/Bethesda/FormComponents.cpp @@ -54,8 +54,6 @@ namespace RE return BSContainer::ForEachResult::kContinue; }); return result; - - return false; } bool BGSKeywordForm::HasKeywordID(std::uint32_t a_formID) const From e85df4abc54fb924d7cab2d9fa03e64f01232f1f Mon Sep 17 00:00:00 2001 From: Qudix <17361645+Qudix@users.noreply.github.com> Date: Tue, 28 May 2024 09:41:46 -0500 Subject: [PATCH 3/5] feat: start moving things from `PCH.h` --- CommonLibF4/cmake/sourcelist.cmake | 1 + CommonLibF4/include/F4SE/Impl/PCH.h | 226 ++-------------------------- CommonLibF4/include/REX/REX.h | 169 +++++++++++++++++++++ 3 files changed, 183 insertions(+), 213 deletions(-) create mode 100644 CommonLibF4/include/REX/REX.h diff --git a/CommonLibF4/cmake/sourcelist.cmake b/CommonLibF4/cmake/sourcelist.cmake index 90d1f0da..f35053a5 100644 --- a/CommonLibF4/cmake/sourcelist.cmake +++ b/CommonLibF4/cmake/sourcelist.cmake @@ -367,6 +367,7 @@ set(SOURCES include/REL/Version.h include/REX/PS4.h include/REX/PS4/SCEPAD.h + include/REX/REX.h include/REX/W32.h include/REX/W32/ADVAPI32.h include/REX/W32/BASE.h diff --git a/CommonLibF4/include/F4SE/Impl/PCH.h b/CommonLibF4/include/F4SE/Impl/PCH.h index 2a5e7441..8bb56cf6 100644 --- a/CommonLibF4/include/F4SE/Impl/PCH.h +++ b/CommonLibF4/include/F4SE/Impl/PCH.h @@ -46,6 +46,7 @@ static_assert( #include #pragma warning(pop) +#include "REX/REX.h" #include "REX/W32/KERNEL32.h" #include "REX/W32/USER32.h" @@ -262,103 +263,22 @@ namespace F4SE std::size_t _left{ 0 }; }; + + // backwards compat template < - class Enum, - class Underlying = std::underlying_type_t> - class enumeration + class E, + class U = std::underlying_type_t> + class enumeration : public REX::EnumSet { - public: - using enum_type = Enum; - using underlying_type = Underlying; - - static_assert(std::is_enum_v, "enum_type must be an enum"); - static_assert(std::is_integral_v, "underlying_type must be an integral"); - - constexpr enumeration() noexcept = default; - - constexpr enumeration(const enumeration&) noexcept = default; - - constexpr enumeration(enumeration&&) noexcept = default; - - template // NOLINTNEXTLINE(google-explicit-constructor) - constexpr enumeration(enumeration a_rhs) noexcept : - _impl(static_cast(a_rhs.get())) - {} + using super = REX::EnumSet; - template - constexpr enumeration(Args... a_values) noexcept // - requires(std::same_as&&...) : - _impl((static_cast(a_values) | ...)) - {} - - ~enumeration() noexcept = default; - - constexpr enumeration& operator=(const enumeration&) noexcept = default; - constexpr enumeration& operator=(enumeration&&) noexcept = default; - - template - constexpr enumeration& operator=(enumeration a_rhs) noexcept - { - _impl = static_cast(a_rhs.get()); - } - - constexpr enumeration& operator=(enum_type a_value) noexcept - { - _impl = static_cast(a_value); - return *this; - } - - [[nodiscard]] explicit constexpr operator bool() const noexcept { return _impl != static_cast(0); } - - [[nodiscard]] constexpr enum_type operator*() const noexcept { return get(); } - [[nodiscard]] constexpr enum_type get() const noexcept { return static_cast(_impl); } - [[nodiscard]] constexpr underlying_type underlying() const noexcept { return _impl; } - - template - constexpr enumeration& set(Args... a_args) noexcept // - requires(std::same_as&&...) - { - _impl |= (static_cast(a_args) | ...); - return *this; - } - - template - constexpr enumeration& reset(Args... a_args) noexcept // - requires(std::same_as&&...) - { - _impl &= ~(static_cast(a_args) | ...); - return *this; - } - - constexpr enumeration& reset() noexcept - { - _impl = 0; - return *this; - } - - template - [[nodiscard]] constexpr bool any(Args... a_args) const noexcept // - requires(std::same_as&&...) - { - return (_impl & (static_cast(a_args) | ...)) != static_cast(0); - } - - template - [[nodiscard]] constexpr bool all(Args... a_args) const noexcept // - requires(std::same_as&&...) - { - return (_impl & (static_cast(a_args) | ...)) == (static_cast(a_args) | ...); - } - - template - [[nodiscard]] constexpr bool none(Args... a_args) const noexcept // - requires(std::same_as&&...) - { - return (_impl & (static_cast(a_args) | ...)) == static_cast(0); - } + public: + using enum_type = E; + using underlying_type = U; - private: - underlying_type _impl{ 0 }; + using super::super; + using super::operator=; + using super::operator*; }; template @@ -369,125 +289,10 @@ namespace F4SE } } -#define F4SE_MAKE_LOGICAL_OP(a_op, a_result) \ - template \ - [[nodiscard]] constexpr a_result operator a_op(enumeration a_lhs, enumeration a_rhs) noexcept \ - { \ - return a_lhs.get() a_op a_rhs.get(); \ - } \ - \ - template \ - [[nodiscard]] constexpr a_result operator a_op(enumeration a_lhs, E a_rhs) noexcept \ - { \ - return a_lhs.get() a_op a_rhs; \ - } - -#define F4SE_MAKE_ARITHMETIC_OP(a_op) \ - template \ - [[nodiscard]] constexpr auto operator a_op(enumeration a_enum, U a_shift) noexcept \ - ->enumeration \ - { \ - return static_cast(static_cast(a_enum.get()) a_op a_shift); \ - } \ - \ - template \ - constexpr auto operator a_op##=(enumeration& a_enum, U a_shift) noexcept \ - ->enumeration& \ - { \ - return a_enum = a_enum a_op a_shift; \ - } - -#define F4SE_MAKE_ENUMERATION_OP(a_op) \ - template \ - [[nodiscard]] constexpr auto operator a_op(enumeration a_lhs, enumeration a_rhs) noexcept \ - ->enumeration> \ - { \ - return static_cast(static_cast(a_lhs.get()) a_op static_cast(a_rhs.get())); \ - } \ - \ - template \ - [[nodiscard]] constexpr auto operator a_op(enumeration a_lhs, E a_rhs) noexcept \ - ->enumeration \ - { \ - return static_cast(static_cast(a_lhs.get()) a_op static_cast(a_rhs)); \ - } \ - \ - template \ - [[nodiscard]] constexpr auto operator a_op(E a_lhs, enumeration a_rhs) noexcept \ - ->enumeration \ - { \ - return static_cast(static_cast(a_lhs) a_op static_cast(a_rhs.get())); \ - } \ - \ - template \ - constexpr auto operator a_op##=(enumeration& a_lhs, enumeration a_rhs) noexcept \ - ->enumeration& \ - { \ - return a_lhs = a_lhs a_op a_rhs; \ - } \ - \ - template \ - constexpr auto operator a_op##=(enumeration& a_lhs, E a_rhs) noexcept \ - ->enumeration& \ - { \ - return a_lhs = a_lhs a_op a_rhs; \ - } \ - \ - template \ - constexpr auto operator a_op##=(E& a_lhs, enumeration a_rhs) noexcept \ - ->E& \ - { \ - return a_lhs = *(a_lhs a_op a_rhs); \ - } - -#define F4SE_MAKE_INCREMENTER_OP(a_op) \ - template \ - constexpr auto operator a_op##a_op(enumeration& a_lhs) noexcept \ - ->enumeration& \ - { \ - return a_lhs a_op## = static_cast(1); \ - } \ - \ - template \ - [[nodiscard]] constexpr auto operator a_op##a_op(enumeration& a_lhs, int) noexcept \ - ->enumeration \ - { \ - const auto tmp = a_lhs; \ - a_op##a_op a_lhs; \ - return tmp; \ - } - namespace F4SE { namespace stl { - template < - class E, - class U> - [[nodiscard]] constexpr auto operator~(enumeration a_enum) noexcept - -> enumeration - { - return static_cast(~static_cast(a_enum.get())); - } - - F4SE_MAKE_LOGICAL_OP(==, bool); - F4SE_MAKE_LOGICAL_OP(<=>, std::strong_ordering); - - F4SE_MAKE_ARITHMETIC_OP(<<); - F4SE_MAKE_ENUMERATION_OP(<<); - F4SE_MAKE_ARITHMETIC_OP(>>); - F4SE_MAKE_ENUMERATION_OP(>>); - - F4SE_MAKE_ENUMERATION_OP(|); - F4SE_MAKE_ENUMERATION_OP(&); - F4SE_MAKE_ENUMERATION_OP(^); - - F4SE_MAKE_ENUMERATION_OP(+); - F4SE_MAKE_ENUMERATION_OP(-); - - F4SE_MAKE_INCREMENTER_OP(+); // ++ - F4SE_MAKE_INCREMENTER_OP(-); // -- - template class atomic_ref : public std::atomic_ref @@ -713,11 +518,6 @@ namespace F4SE } } -#undef F4SE_MAKE_INCREMENTER_OP -#undef F4SE_MAKE_ENUMERATION_OP -#undef F4SE_MAKE_ARITHMETIC_OP -#undef F4SE_MAKE_LOGICAL_OP - namespace RE { using namespace std::literals; diff --git a/CommonLibF4/include/REX/REX.h b/CommonLibF4/include/REX/REX.h new file mode 100644 index 00000000..9bdc966f --- /dev/null +++ b/CommonLibF4/include/REX/REX.h @@ -0,0 +1,169 @@ +#pragma once + +namespace REX +{ + template < + class E, + class U = std::underlying_type_t> + class EnumSet + { + public: + using enum_type = E; + using underlying_type = U; + + static_assert(std::is_enum_v, "EnumSet must be an enum"); + static_assert(std::is_integral_v, "EnumSet<..., U> must be an integral"); + + constexpr EnumSet() noexcept = default; + constexpr EnumSet(const EnumSet&) noexcept = default; + constexpr EnumSet(EnumSet&&) noexcept = default; + + template // NOLINTNEXTLINE(google-explicit-constructor) + constexpr EnumSet(EnumSet a_rhs) noexcept : + _impl(static_cast(a_rhs.get())) + {} + + template + constexpr EnumSet(Args... a_values) noexcept + requires(std::same_as&&...) : + _impl((static_cast(a_values) | ...)) + {} + + ~EnumSet() noexcept = default; + + constexpr EnumSet& operator=(const EnumSet&) noexcept = default; + constexpr EnumSet& operator=(EnumSet&&) noexcept = default; + + template + constexpr EnumSet& operator=(EnumSet a_rhs) noexcept + { + _impl = static_cast(a_rhs.get()); + } + + constexpr EnumSet& operator=(E a_value) noexcept + { + _impl = static_cast(a_value); + return *this; + } + + public: + [[nodiscard]] explicit constexpr operator bool() const noexcept { return _impl != static_cast(0); } + + [[nodiscard]] constexpr E operator*() const noexcept { return get(); } + [[nodiscard]] constexpr E get() const noexcept { return static_cast(_impl); } + [[nodiscard]] constexpr U underlying() const noexcept { return _impl; } + + public: + template + constexpr EnumSet& set(Args... a_args) noexcept + requires(std::same_as&&...) + { + _impl |= (static_cast(a_args) | ...); + return *this; + } + + template + constexpr EnumSet& reset(Args... a_args) noexcept + requires(std::same_as&&...) + { + _impl &= ~(static_cast(a_args) | ...); + return *this; + } + + constexpr EnumSet& reset() noexcept + { + _impl = 0; + return *this; + } + + template + [[nodiscard]] constexpr bool any(Args... a_args) const noexcept + requires(std::same_as&&...) + { + return (_impl & (static_cast(a_args) | ...)) != static_cast(0); + } + + template + [[nodiscard]] constexpr bool all(Args... a_args) const noexcept + requires(std::same_as&&...) + { + return (_impl & (static_cast(a_args) | ...)) == (static_cast(a_args) | ...); + } + + template + [[nodiscard]] constexpr bool none(Args... a_args) const noexcept + requires(std::same_as&&...) + { + return (_impl & (static_cast(a_args) | ...)) == static_cast(0); + } + + public: + friend constexpr bool operator==(EnumSet a_lhs, EnumSet a_rhs) noexcept { return a_lhs.underlying() == a_rhs.underlying(); } + friend constexpr bool operator==(EnumSet a_lhs, E a_rhs) noexcept { return a_lhs.underlying() == static_cast(a_rhs); } + friend constexpr bool operator==(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs) == a_rhs.underlying(); } + + friend constexpr std::strong_ordering operator<=>(EnumSet a_lhs, EnumSet a_rhs) noexcept { return a_lhs.underlying() <=> a_rhs.underlying(); } + friend constexpr std::strong_ordering operator<=>(EnumSet a_lhs, E a_rhs) noexcept { return a_lhs.underlying() <=> static_cast(a_rhs); } + friend constexpr std::strong_ordering operator<=>(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs) <=> a_rhs.underlying(); } + + friend constexpr EnumSet operator&(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() & a_rhs.underlying()); } + friend constexpr EnumSet operator&(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() & static_cast(a_rhs)); } + friend constexpr EnumSet operator&(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) & a_rhs.underlying()); } + + friend constexpr EnumSet& operator&=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs & a_rhs; } + friend constexpr EnumSet& operator&=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs & a_rhs; } + + friend constexpr EnumSet operator|(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() | a_rhs.underlying()); } + friend constexpr EnumSet operator|(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() | static_cast(a_rhs)); } + friend constexpr EnumSet operator|(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) | a_rhs.underlying()); } + + friend constexpr EnumSet& operator|=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs | a_rhs; } + friend constexpr EnumSet& operator|=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs | a_rhs; } + + friend constexpr EnumSet operator^(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() ^ a_rhs.underlying()); } + friend constexpr EnumSet operator^(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() ^ static_cast(a_rhs)); } + friend constexpr EnumSet operator^(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) ^ a_rhs.underlying()); } + + friend constexpr EnumSet& operator^=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs ^ a_rhs; } + friend constexpr EnumSet& operator^=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs ^ a_rhs; } + + friend constexpr EnumSet operator+(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() + a_rhs.underlying()); } + friend constexpr EnumSet operator+(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() + static_cast(a_rhs)); } + friend constexpr EnumSet operator+(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) + a_rhs.underlying()); } + + friend constexpr EnumSet& operator+=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs + a_rhs; } + friend constexpr EnumSet& operator+=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs + a_rhs; } + + friend constexpr EnumSet operator-(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() - a_rhs.underlying()); } + friend constexpr EnumSet operator-(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() - static_cast(a_rhs)); } + friend constexpr EnumSet operator-(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) - a_rhs.underlying()); } + + friend constexpr EnumSet& operator-=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs - a_rhs; } + friend constexpr EnumSet& operator-=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs - a_rhs; } + + friend constexpr EnumSet operator<<(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() << a_rhs.underlying()); } + friend constexpr EnumSet operator<<(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() << static_cast(a_rhs)); } + friend constexpr EnumSet operator<<(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) << a_rhs.underlying()); } + + friend constexpr EnumSet& operator<<=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs << a_rhs; } + friend constexpr EnumSet& operator<<=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs << a_rhs; } + + friend constexpr EnumSet operator>>(EnumSet a_lhs, EnumSet a_rhs) noexcept { return static_cast(a_lhs.underlying() >> a_rhs.underlying()); } + friend constexpr EnumSet operator>>(EnumSet a_lhs, E a_rhs) noexcept { return static_cast(a_lhs.underlying() >> static_cast(a_rhs)); } + friend constexpr EnumSet operator>>(E a_lhs, EnumSet a_rhs) noexcept { return static_cast(static_cast(a_lhs) >> a_rhs.underlying()); } + + friend constexpr EnumSet& operator>>=(EnumSet& a_lhs, EnumSet a_rhs) noexcept { return a_lhs = a_lhs >> a_rhs; } + friend constexpr EnumSet& operator>>=(EnumSet& a_lhs, E a_rhs) noexcept { return a_lhs = a_lhs >> a_rhs; } + + friend constexpr EnumSet& operator~(EnumSet& a_lhs) noexcept { return a_lhs = ~a_lhs.underlying(); } + + private: + U _impl{ 0 }; + }; + + template + EnumSet(Args...) -> EnumSet< + std::common_type_t, + std::underlying_type_t< + std::common_type_t>>; +} From b26fb7c43b0d874555035333f85d8c81ebed77a4 Mon Sep 17 00:00:00 2001 From: Qudix <17361645+Qudix@users.noreply.github.com> Date: Tue, 28 May 2024 11:16:50 -0500 Subject: [PATCH 4/5] feat: change `stl::enumeration` to `REX::EnumSet` --- .../include/RE/Bethesda/ActiveEffect.h | 34 +- CommonLibF4/include/RE/Bethesda/Actor.h | 110 ++--- .../include/RE/Bethesda/ActorValueInfo.h | 30 +- .../include/RE/Bethesda/BGSBaseAliases.h | 10 +- .../include/RE/Bethesda/BGSCharacterTint.h | 10 +- .../RE/Bethesda/BGSDefaultObjectManager.h | 16 +- CommonLibF4/include/RE/Bethesda/BGSHeadPart.h | 20 +- .../include/RE/Bethesda/BGSInventoryItem.h | 8 +- CommonLibF4/include/RE/Bethesda/BGSMod.h | 12 +- .../include/RE/Bethesda/BGSPrimitive.h | 6 +- CommonLibF4/include/RE/Bethesda/BGSSaveLoad.h | 2 +- .../include/RE/Bethesda/BGSSceneAction.h | 12 +- .../include/RE/Bethesda/BGSTextureSet.h | 226 ++++----- CommonLibF4/include/RE/Bethesda/BSExtraData.h | 18 +- CommonLibF4/include/RE/Bethesda/BSGraphics.h | 88 ++-- .../RE/Bethesda/BSInputDeviceManager.h | 2 +- .../RE/Bethesda/BSInputEnableManager.h | 24 +- .../include/RE/Bethesda/BSMTAManager.h | 10 +- CommonLibF4/include/RE/Bethesda/BSModelDB.h | 16 +- .../Bethesda/BSScript/Internal/CodeTasklet.h | 28 +- .../BSScript/Internal/ReadableStringTable.h | 2 +- .../BSScript/Internal/ScriptFunction.h | 34 +- .../BSScript/Internal/VirtualMachine.h | 2 +- .../BSScript/Internal/WritableStringTable.h | 2 +- .../RE/Bethesda/BSScript/PropertyTypeInfo.h | 20 +- .../include/RE/Bethesda/BSScript/Stack.h | 28 +- .../RE/Bethesda/BSScript/StructTypeInfo.h | 10 +- .../include/RE/Bethesda/BSScript/TypeInfo.h | 2 +- .../include/RE/Bethesda/BSShaderProperty.h | 22 +- CommonLibF4/include/RE/Bethesda/ControlMap.h | 36 +- CommonLibF4/include/RE/Bethesda/Events.h | 66 +-- .../include/RE/Bethesda/FormComponents.h | 42 +- CommonLibF4/include/RE/Bethesda/HUDModes.h | 6 +- CommonLibF4/include/RE/Bethesda/IMenu.h | 180 +++---- CommonLibF4/include/RE/Bethesda/InputEvent.h | 14 +- CommonLibF4/include/RE/Bethesda/Interface3D.h | 122 ++--- CommonLibF4/include/RE/Bethesda/MagicItems.h | 28 +- .../include/RE/Bethesda/MessageMenuManager.h | 24 +- CommonLibF4/include/RE/Bethesda/NavMesh.h | 4 +- .../include/RE/Bethesda/PipboyManager.h | 54 +-- .../include/RE/Bethesda/PlayerCharacter.h | 448 +++++++++--------- .../include/RE/Bethesda/PlayerControls.h | 10 +- CommonLibF4/include/RE/Bethesda/Projectiles.h | 192 ++++---- CommonLibF4/include/RE/Bethesda/Script.h | 54 +-- CommonLibF4/include/RE/Bethesda/Sky.h | 4 +- .../include/RE/Bethesda/TESBoundAnimObjects.h | 2 +- .../include/RE/Bethesda/TESBoundObjects.h | 132 +++--- CommonLibF4/include/RE/Bethesda/TESCamera.h | 4 +- .../include/RE/Bethesda/TESCondition.h | 26 +- CommonLibF4/include/RE/Bethesda/TESFile.h | 6 +- CommonLibF4/include/RE/Bethesda/TESForms.h | 276 +++++------ .../include/RE/Bethesda/TESObjectREFRs.h | 16 +- CommonLibF4/include/RE/Bethesda/TESPackages.h | 56 +-- CommonLibF4/include/RE/Bethesda/TESRace.h | 88 ++-- .../include/RE/Bethesda/TESWorldSpace.h | 2 +- CommonLibF4/include/RE/Bethesda/UIMessage.h | 4 +- .../include/RE/Bethesda/UIShaderFXInfo.h | 10 +- CommonLibF4/include/RE/Bethesda/VATS.h | 54 +-- .../RE/Bethesda/bhkCharacterController.h | 144 +++--- CommonLibF4/include/RE/Havok/hkBaseTypes.h | 4 +- .../include/RE/Havok/hknpCharacterContext.h | 20 +- .../include/RE/Havok/hknpCollisionResult.h | 14 +- .../include/RE/NetImmerse/NiCloningProcess.h | 10 +- .../include/RE/NetImmerse/NiController.h | 2 +- CommonLibF4/include/RE/NetImmerse/NiFile.h | 16 +- CommonLibF4/include/RE/RTTI.h | 26 +- .../include/RE/Scaleform/GFx/GFx_Player.h | 8 +- .../include/RE/Scaleform/Kernel/SF_Types.h | 2 +- .../RE/Scaleform/Render/Render_Context.h | 10 +- .../RE/Scaleform/Render/Render_Viewport.h | 22 +- 70 files changed, 1521 insertions(+), 1521 deletions(-) diff --git a/CommonLibF4/include/RE/Bethesda/ActiveEffect.h b/CommonLibF4/include/RE/Bethesda/ActiveEffect.h index 8e2238b1..bedfdf39 100644 --- a/CommonLibF4/include/RE/Bethesda/ActiveEffect.h +++ b/CommonLibF4/include/RE/Bethesda/ActiveEffect.h @@ -62,23 +62,23 @@ namespace RE } // members - ActiveEffectReferenceEffectController hitEffectController; // 0C - BSSoundHandle persistentSound; // 30 - ActorHandle caster; // 38 - NiPointer sourceNode; // 40 - MagicItem* spell; // 48 - EffectItem* effect; // 50 - MagicTarget* target; // 58 - TESBoundObject* source; // 60 - BSSimpleList* hitEffects; // 68 - MagicItem* displacementSpell; // 70 - float elapsedSeconds; // 74 - float duration; // 78 - float magnitude; // 7C - stl::enumeration flags; // 80 - stl::enumeration conditionStatus; // 84 - std::uint16_t uniqueID; // 8C - stl::enumeration castingSource; // 90 + ActiveEffectReferenceEffectController hitEffectController; // 0C + BSSoundHandle persistentSound; // 30 + ActorHandle caster; // 38 + NiPointer sourceNode; // 40 + MagicItem* spell; // 48 + EffectItem* effect; // 50 + MagicTarget* target; // 58 + TESBoundObject* source; // 60 + BSSimpleList* hitEffects; // 68 + MagicItem* displacementSpell; // 70 + float elapsedSeconds; // 74 + float duration; // 78 + float magnitude; // 7C + REX::EnumSet flags; // 80 + REX::EnumSet conditionStatus; // 84 + std::uint16_t uniqueID; // 8C + REX::EnumSet castingSource; // 90 }; static_assert(sizeof(ActiveEffect) == 0x98); } diff --git a/CommonLibF4/include/RE/Bethesda/Actor.h b/CommonLibF4/include/RE/Bethesda/Actor.h index 91528251..f471e56b 100644 --- a/CommonLibF4/include/RE/Bethesda/Actor.h +++ b/CommonLibF4/include/RE/Bethesda/Actor.h @@ -326,7 +326,7 @@ namespace RE NiPoint3 furniturePathPoint; // 0DC NiPoint3 lastSeenPosition; // 0E8 ActorHandle bleedoutAttacker; // 0F4 - stl::enumeration wardState; // 0F8 + REX::EnumSet wardState; // 0F8 BSTSmartPointer> animResponse; // 100 BSTArray commandedActors; // 108 NiNode* damageRootNode[26]; // 120 @@ -398,7 +398,7 @@ namespace RE std::uint64_t nextExtraArrow3DUpdate; // 480 std::uint32_t deferredKill; // 488 std::uint32_t flareFlags; // 48C - stl::enumeration useItem; // 490 + REX::EnumSet useItem; // 490 std::int16_t animActionSuccess; // 494 std::uint16_t update3DModel; // 496 std::int8_t weaponCullCounter; // 498 @@ -1227,59 +1227,59 @@ namespace RE } // members - NiTFlags niFlags; // 2D0 - float updateTargetTimer; // 2D4 - NiPoint3 editorLocCoord; // 2D8 - NiPoint3 editorLocRot; // 2E4 - TESForm* editorLocForm; // 2F0 - BGSLocation* editorLocation; // 2F8 - AIProcess* currentProcess; // 300 - ActorMover* actorMover; // 308 - BGSKeyword* speakingAnimArchType; // 310 - BSTSmartPointer movementController; // 318 - TESPackage* initialPackage; // 320 - CombatController* combatController; // 328 - TESFaction* vendorFaction; // 330 - ActorValueStorage avStorage; // 338 - BGSDialogueBranch* exclusiveBranch; // 370 - stl::enumeration criticalStage; // 378 - ObjectRefHandle dialogueItemTarget; // 37C - ActorHandle currentCombatTarget; // 380 - ActorHandle myKiller; // 384 - float checkMyDeadBodyTimer; // 388 - float voiceTimer; // 38C - float voiceLengthTotal; // 390 - float underWaterTimer; // 394 - std::int32_t thiefCrimeStamp; // 398 - std::int32_t actionValue; // 39C - float timeronAction; // 3A0 - AITimeStamp calculateVendorFactionTimer; // 3A4 - std::uint32_t intimidateBribeDayStamp; // 3A8 - float equippedWeight; // 3AC - BSTSmallArray addedSpells; // 3B0 - ActorMagicCaster* magicCasters[4]; // 3C8 - MagicItem* selectedSpell[4]; // 3E8 - CastPowerItem* castPowerItems; // 408 - TESForm* selectedPower; // 410 - TESRace* race; // 418 - Perks* perks; // 420 - BSTSmartPointer biped; // 428 - BSNonReentrantSpinLock addingToOrRemovingFromScene; // 430 - BSReadWriteLock perkArrayLock; // 434 - stl::enumeration boolFlags; // 43C - std::uint32_t moreFlags; // 440 - Modifiers healthModifiers; // 444 - Modifiers actionPointsModifiers; // 450 - Modifiers staminaModifiers; // 45C - Modifiers radsModifiers; // 468 - float lastUpdate; // 474 - std::uint32_t lastSeenTime; // 478 - float armorRating; // 47C - float armorBaseFactorSum; // 480 - std::uint32_t visFlags: 4; // 484:00 - std::int8_t raceSwitchPending: 1; // 488:0 - std::int8_t soundCallBackSet; // 489 - bool trespassing; // 48A + NiTFlags niFlags; // 2D0 + float updateTargetTimer; // 2D4 + NiPoint3 editorLocCoord; // 2D8 + NiPoint3 editorLocRot; // 2E4 + TESForm* editorLocForm; // 2F0 + BGSLocation* editorLocation; // 2F8 + AIProcess* currentProcess; // 300 + ActorMover* actorMover; // 308 + BGSKeyword* speakingAnimArchType; // 310 + BSTSmartPointer movementController; // 318 + TESPackage* initialPackage; // 320 + CombatController* combatController; // 328 + TESFaction* vendorFaction; // 330 + ActorValueStorage avStorage; // 338 + BGSDialogueBranch* exclusiveBranch; // 370 + REX::EnumSet criticalStage; // 378 + ObjectRefHandle dialogueItemTarget; // 37C + ActorHandle currentCombatTarget; // 380 + ActorHandle myKiller; // 384 + float checkMyDeadBodyTimer; // 388 + float voiceTimer; // 38C + float voiceLengthTotal; // 390 + float underWaterTimer; // 394 + std::int32_t thiefCrimeStamp; // 398 + std::int32_t actionValue; // 39C + float timeronAction; // 3A0 + AITimeStamp calculateVendorFactionTimer; // 3A4 + std::uint32_t intimidateBribeDayStamp; // 3A8 + float equippedWeight; // 3AC + BSTSmallArray addedSpells; // 3B0 + ActorMagicCaster* magicCasters[4]; // 3C8 + MagicItem* selectedSpell[4]; // 3E8 + CastPowerItem* castPowerItems; // 408 + TESForm* selectedPower; // 410 + TESRace* race; // 418 + Perks* perks; // 420 + BSTSmartPointer biped; // 428 + BSNonReentrantSpinLock addingToOrRemovingFromScene; // 430 + BSReadWriteLock perkArrayLock; // 434 + REX::EnumSet boolFlags; // 43C + std::uint32_t moreFlags; // 440 + Modifiers healthModifiers; // 444 + Modifiers actionPointsModifiers; // 450 + Modifiers staminaModifiers; // 45C + Modifiers radsModifiers; // 468 + float lastUpdate; // 474 + std::uint32_t lastSeenTime; // 478 + float armorRating; // 47C + float armorBaseFactorSum; // 480 + std::uint32_t visFlags: 4; // 484:00 + std::int8_t raceSwitchPending: 1; // 488:0 + std::int8_t soundCallBackSet; // 489 + bool trespassing; // 48A }; static_assert(sizeof(Actor) == 0x490); diff --git a/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h b/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h index 8e47d90a..4607fcad 100644 --- a/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h +++ b/CommonLibF4/include/RE/Bethesda/ActorValueInfo.h @@ -215,21 +215,21 @@ namespace RE using DerivationFunction_t = float(const ActorValueOwner* a_actor, const ActorValueInfo& a_info); // members - std::function modifiedCallback; // 048 - BSStringT formEditorID; // 088 - ActorValueInfo* dependentActorValues[15]; // 098 - std::function derivationFunction; // 110 - const char* enumNames[10]; // 150 - BGSLocalizedString abbreviation; // 1A0 - std::int32_t oldActorValue; // 1A8 - stl::enumeration flags; // 1AC - stl::enumeration avType; // 1B0 - std::uint32_t numDependentActorValues; // 1B4 - std::uint32_t enumCount; // 1B8 - std::int32_t fullCacheIndex; // 1BC - std::int32_t permanentCacheIndex; // 1C0 - float defaultValue; // 1C4 - std::uint32_t sortIndex; // 1C8 + std::function modifiedCallback; // 048 + BSStringT formEditorID; // 088 + ActorValueInfo* dependentActorValues[15]; // 098 + std::function derivationFunction; // 110 + const char* enumNames[10]; // 150 + BGSLocalizedString abbreviation; // 1A0 + std::int32_t oldActorValue; // 1A8 + REX::EnumSet flags; // 1AC + REX::EnumSet avType; // 1B0 + std::uint32_t numDependentActorValues; // 1B4 + std::uint32_t enumCount; // 1B8 + std::int32_t fullCacheIndex; // 1BC + std::int32_t permanentCacheIndex; // 1C0 + float defaultValue; // 1C4 + std::uint32_t sortIndex; // 1C8 }; static_assert(sizeof(ActorValueInfo) == 0x1D0); } diff --git a/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h b/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h index 06bcefc1..48b96d48 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h +++ b/CommonLibF4/include/RE/Bethesda/BGSBaseAliases.h @@ -55,11 +55,11 @@ namespace RE [[nodiscard]] bool IsQuestObject() const noexcept { return flags.all(FLAGS::kQuestObject); } // mmebers - BSFixedString aliasName; // 08 - TESQuest* owningQuest; // 10 - std::uint32_t aliasID; // 18 - stl::enumeration flags; // 1C - std::uint16_t fillType; // 20 + BSFixedString aliasName; // 08 + TESQuest* owningQuest; // 10 + std::uint32_t aliasID; // 18 + REX::EnumSet flags; // 1C + std::uint16_t fillType; // 20 }; static_assert(sizeof(BGSBaseAlias) == 0x28); diff --git a/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h b/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h index 8d70dfac..649f36ff 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h +++ b/CommonLibF4/include/RE/Bethesda/BGSCharacterTint.h @@ -84,11 +84,11 @@ namespace RE virtual void LoadImpl(TESFile* a_file) = 0; // 04 // members - BGSLocalizedString name; // 08 - TESCondition chargenConditions; // 10 - stl::enumeration slot; // 18 - const std::uint16_t uniqueID{ 0 }; // 1C - std::int8_t flags; // 1E + BGSLocalizedString name; // 08 + TESCondition chargenConditions; // 10 + REX::EnumSet slot; // 18 + const std::uint16_t uniqueID{ 0 }; // 1C + std::int8_t flags; // 1E }; static_assert(sizeof(Entry) == 0x20); diff --git a/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h b/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h index 0404002c..aa306a69 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h +++ b/CommonLibF4/include/RE/Bethesda/BGSDefaultObjectManager.h @@ -420,11 +420,11 @@ namespace RE { public: // members - const char* name; // 00 - stl::enumeration type; // 08 - std::uint32_t uniqueID; // 0C - stl::enumeration doType; // 10 - const char* newObjectName; // 18 + const char* name; // 00 + REX::EnumSet type; // 08 + std::uint32_t uniqueID; // 0C + REX::EnumSet doType; // 10 + const char* newObjectName; // 18 }; static_assert(sizeof(DEFAULT_OBJECT_DATA) == 0x20); @@ -500,9 +500,9 @@ namespace RE } // members - TESForm* form; // 20 - stl::enumeration type; // 28 - BSFixedString formEditorID; // 30 + TESForm* form; // 20 + REX::EnumSet type; // 28 + BSFixedString formEditorID; // 30 private: BGSDefaultObject* ctor(const char* a_name, ENUM_FORM_ID a_formType, const char* a_description) diff --git a/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h b/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h index 91003c97..0b22fec4 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h +++ b/CommonLibF4/include/RE/Bethesda/BGSHeadPart.h @@ -45,16 +45,16 @@ namespace RE [[nodiscard]] bool IsExtraPart() const noexcept { return flags.all(Flag::kExtraPart); } // members - stl::enumeration flags; // 070 - stl::enumeration type; // 074 - BSTArray extraParts; // 078 - BGSTextureSet* textureSet; // 090 - TESModel ChargenModel; // 098 - TESModelTri morphs[3]; // 0C8 - BGSColorForm* colorForm; // 158 - BGSListForm* validRaces; // 160 - TESCondition chargenConditions; // 168 - BSFixedString formEditorID; // 170 + REX::EnumSet flags; // 070 + REX::EnumSet type; // 074 + BSTArray extraParts; // 078 + BGSTextureSet* textureSet; // 090 + TESModel ChargenModel; // 098 + TESModelTri morphs[3]; // 0C8 + BGSColorForm* colorForm; // 158 + BGSListForm* validRaces; // 160 + TESCondition chargenConditions; // 168 + BSFixedString formEditorID; // 170 }; static_assert(sizeof(BGSHeadPart) == 0x178); } diff --git a/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h b/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h index b4b92f6e..25558e6e 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h +++ b/CommonLibF4/include/RE/Bethesda/BGSInventoryItem.h @@ -42,10 +42,10 @@ namespace RE [[nodiscard]] bool IsEquipped() const noexcept { return flags.any(Flag::kSlotMask); } // members - BSTSmartPointer nextStack; // 10 - BSTSmartPointer extra; // 18 - std::uint32_t count; // 20 - stl::enumeration flags; // 24 + BSTSmartPointer nextStack; // 10 + BSTSmartPointer extra; // 18 + std::uint32_t count; // 20 + REX::EnumSet flags; // 24 }; static_assert(sizeof(Stack) == 0x28); diff --git a/CommonLibF4/include/RE/Bethesda/BGSMod.h b/CommonLibF4/include/RE/Bethesda/BGSMod.h index 3ae74497..e7cc237c 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSMod.h +++ b/CommonLibF4/include/RE/Bethesda/BGSMod.h @@ -155,11 +155,11 @@ namespace RE::BGSMod { public: // members - stl::enumeration targetFormType; // 18 - std::int8_t maxRank; // 19 - std::int8_t lvlsPerTierScaledOffset; // 1A - bool optional; // 1B - bool childrenExclusive; // 1C + REX::EnumSet targetFormType; // 18 + std::int8_t maxRank; // 19 + std::int8_t lvlsPerTierScaledOffset; // 1A + bool optional; // 1B + bool childrenExclusive; // 1C }; static_assert(sizeof(Data) == 0x20); @@ -195,7 +195,7 @@ namespace RE::BGSMod BGSAttachParentArray attachParents; // 98 BGSTypedKeywordValueArray filterKeywords; // B0 BGSTypedKeywordValue attachPoint; // C0 - stl::enumeration targetFormType; // C2 + REX::EnumSet targetFormType; // C2 std::uint8_t maxRank; // C3 std::uint8_t lvlsPerTierScaledOffset; // C4 std::int8_t priority; // C5 diff --git a/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h b/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h index 18b1ccb6..509b0004 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h +++ b/CommonLibF4/include/RE/Bethesda/BGSPrimitive.h @@ -34,9 +34,9 @@ namespace RE virtual BSMultiBoundShape* MakeMultiBoundShape([[maybe_unused]] const NiPoint3& a_angle) const { return nullptr; } // 04 // members - stl::enumeration type; // 08 - NiPoint3 radii; // 0C - NiPointer node; // 18 + REX::EnumSet type; // 08 + NiPoint3 radii; // 0C + NiPointer node; // 18 }; static_assert(sizeof(BGSPrimitive) == 0x20); } diff --git a/CommonLibF4/include/RE/Bethesda/BGSSaveLoad.h b/CommonLibF4/include/RE/Bethesda/BGSSaveLoad.h index 3438ddc8..0bfe49cd 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSSaveLoad.h +++ b/CommonLibF4/include/RE/Bethesda/BGSSaveLoad.h @@ -39,7 +39,7 @@ namespace RE union { std::uint8_t data1; - stl::enumeration flags; + REX::EnumSet flags; }; // 0 std::uint8_t data2; // 1 std::uint8_t data3; // 2 diff --git a/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h b/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h index 00b76e64..b6e2200d 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h +++ b/CommonLibF4/include/RE/Bethesda/BGSSceneAction.h @@ -99,12 +99,12 @@ namespace RE virtual void UpdateAction(BGSScene* scene); // 14 // members - std::uint32_t actorID; // 08 - std::uint16_t startPhase; // 0C - std::uint16_t endPhase; // 0E - stl::enumeration flags; // 10 - stl::enumeration status; // 14 - std::uint32_t uniqueID; // 18 + std::uint32_t actorID; // 08 + std::uint16_t startPhase; // 0C + std::uint16_t endPhase; // 0E + REX::EnumSet flags; // 10 + REX::EnumSet status; // 14 + std::uint32_t uniqueID; // 18 }; static_assert(sizeof(BGSSceneAction) == 0x20); diff --git a/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h b/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h index 3e6b9250..757974c4 100644 --- a/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h +++ b/CommonLibF4/include/RE/Bethesda/BGSTextureSet.h @@ -39,119 +39,119 @@ namespace RE }; // members - stl::enumeration lightingShader; // 004 - bool specularEnabled; // 008 - NiColor specularColor; // 00C - float specularMult; // 018 - NiColor emittanceColor; // 01C - float emittanceColorScale; // 028 - float lightingInfluence; // 02C - std::int8_t envmapMinLOD; // 030 - float smoothness; // 034 - float fresnelPower_ShaderDataEntry; // 038 - float wetnessControl_SpecScale_ShaderDataEntry; // 03C - float wetnessControl_SpecPowerScale_ShaderDataEntry; // 040 - float wetnessControl_SpecMin_ShaderDataEntry; // 044 - float wetnessControl_EnvMapScale_ShaderDataEntry; // 048 - float wetnessControl_FresnelPower_ShaderDataEntry; // 04C - float wetnessControl_Metalness_ShaderDataEntry; // 050 - bool betnessControl_ScreenSpaceReflections; // 054 - BSFixedString rootMaterialPath; // 058 - float alpha; // 060 - float emittanceMult; // 064 - float lookupScale; // 068 - bool emitEnabled; // 06C - BSFixedString materialPath; // 070 - bool alphaBlend; // 078 - stl::enumeration alphaSrcBlendMode; // 07C - stl::enumeration alphaDestBlendMode; // 080 - bool alphaTest; // 084 - stl::enumeration alphaTestFunction; // 088 - std::int8_t alphaTestRef; // 08C - bool enableEditorAlphaRef; // 08D - bool vertexColors; // 08E - bool vertexAlpha; // 08F - bool modelSpaceNormals; // 090 - bool decal; // 091 - bool externalEmittance; // 092 - bool hideSecret; // 093 - bool noFade; // 094 - bool dismemberment; // 095 - bool facegen; // 096 - bool skinTint; // 097 - bool hair; // 098 - bool twoSided; // 099 - bool tree; // 09A - bool bloodEnabled; // 09B - bool uniqueAlphaProperty; // 09C - bool effectLightingEnabled; // 09D - bool castShadows; // 09E - bool receiveShadows; // 09F - bool dissolveFade; // 0A0 - bool glowmap; // 0A1 - bool assumeShadowmask; // 0A2 - bool screenSpaceReflections; // 0A3 - bool nonOccluder; // 0A4 - bool skewSpecularAlpha; // 0A5 - bool tessellate; // 0A6 - bool backLighting; // 0A7 - bool subSurfaceLighting; // 0A8 - bool rimLighting; // 0A9 - float subSurfaceRolloff; // 0AC - float rimPower; // 0B0 - float backLightPower; // 0B4 - bool anisoLighting; // 0B8 - bool zBufferWrite; // 0B8 - bool zBufferTest; // 0BA - bool refraction; // 0BB - float refractionPower; // 0BC - bool refractionFalloff; // 0C0 - BSTArray lightingFloatControllers; // 0C8 - BSTArray lightingUShortControllers; // 0E0 - BSTArray lightingColorControllers; // 0F8 - BSTArray effectFloatControllers; // 110 - BSTArray effectColorControllers; // 128 - BSNiAlphaPropertyTestRefController* alphaRefTestController; // 140 - bool parallax; // 148 - bool parallaxOcclusion; // 149 - bool multiLayerParallax; // 14A - float parallaxOcclusionHeightScale; // 14C - float parallaxOcclusionMaxPasses; // 150 - float parallaxLayerThickness; // 154 - float parallaxRefractionScale; // 158 - float parallaxInnerLayerUScale; // 15C - float parallaxInnerLayerVScale; // 160 - float displacementTextureBias; // 164 - float displacementTextureScale; // 168 - float tessellationPNScale; // 16C - float tessellationFadeDistance; // 170 - float tessellationBaseFactor; // 174 - bool tessellationNeedsDominantUVs; // 178 - bool tessellationNeedsCrackFreeNormals; // 179 - bool environmentMapping; // 17A - bool environmentMappingEye; // 17B - bool environmentMappingWindow; // 17C - float environmentMappingMaskScale; // 180 - std::int32_t skyTYpe; // 184 - bool reflectionsEnabled; // 188 - bool silhouetteReflectionsEnabled; // 189 - bool refractionsEnabled; // 18A - bool depthEnabled; // 18B - bool vertexUVEnabled; // 18C - bool vertexAlphaDepthEnabled; // 18D - bool foggingEnabled; // 18E - bool falloffEnabled; // 18F - bool rgbFalloffEnabled; // 190 - NiColorA falloffData; // 194 - bool softEnabled; // 1A4 - float softDepth; // 1A8 - NiPoint2 uvOffset; // 1AC - NiPoint2 uvScale; // 1B4 - bool grayscaleToPaletteColor; // 1BC - bool grayscaleToPaletteAlpha; // 1BD - NiColor hairTintColor; // 1C0 - NiPointer textureSet; // 1D0 - stl::enumeration clampMode; // 1D8 + REX::EnumSet lightingShader; // 004 + bool specularEnabled; // 008 + NiColor specularColor; // 00C + float specularMult; // 018 + NiColor emittanceColor; // 01C + float emittanceColorScale; // 028 + float lightingInfluence; // 02C + std::int8_t envmapMinLOD; // 030 + float smoothness; // 034 + float fresnelPower_ShaderDataEntry; // 038 + float wetnessControl_SpecScale_ShaderDataEntry; // 03C + float wetnessControl_SpecPowerScale_ShaderDataEntry; // 040 + float wetnessControl_SpecMin_ShaderDataEntry; // 044 + float wetnessControl_EnvMapScale_ShaderDataEntry; // 048 + float wetnessControl_FresnelPower_ShaderDataEntry; // 04C + float wetnessControl_Metalness_ShaderDataEntry; // 050 + bool betnessControl_ScreenSpaceReflections; // 054 + BSFixedString rootMaterialPath; // 058 + float alpha; // 060 + float emittanceMult; // 064 + float lookupScale; // 068 + bool emitEnabled; // 06C + BSFixedString materialPath; // 070 + bool alphaBlend; // 078 + REX::EnumSet alphaSrcBlendMode; // 07C + REX::EnumSet alphaDestBlendMode; // 080 + bool alphaTest; // 084 + REX::EnumSet alphaTestFunction; // 088 + std::int8_t alphaTestRef; // 08C + bool enableEditorAlphaRef; // 08D + bool vertexColors; // 08E + bool vertexAlpha; // 08F + bool modelSpaceNormals; // 090 + bool decal; // 091 + bool externalEmittance; // 092 + bool hideSecret; // 093 + bool noFade; // 094 + bool dismemberment; // 095 + bool facegen; // 096 + bool skinTint; // 097 + bool hair; // 098 + bool twoSided; // 099 + bool tree; // 09A + bool bloodEnabled; // 09B + bool uniqueAlphaProperty; // 09C + bool effectLightingEnabled; // 09D + bool castShadows; // 09E + bool receiveShadows; // 09F + bool dissolveFade; // 0A0 + bool glowmap; // 0A1 + bool assumeShadowmask; // 0A2 + bool screenSpaceReflections; // 0A3 + bool nonOccluder; // 0A4 + bool skewSpecularAlpha; // 0A5 + bool tessellate; // 0A6 + bool backLighting; // 0A7 + bool subSurfaceLighting; // 0A8 + bool rimLighting; // 0A9 + float subSurfaceRolloff; // 0AC + float rimPower; // 0B0 + float backLightPower; // 0B4 + bool anisoLighting; // 0B8 + bool zBufferWrite; // 0B8 + bool zBufferTest; // 0BA + bool refraction; // 0BB + float refractionPower; // 0BC + bool refractionFalloff; // 0C0 + BSTArray lightingFloatControllers; // 0C8 + BSTArray lightingUShortControllers; // 0E0 + BSTArray lightingColorControllers; // 0F8 + BSTArray effectFloatControllers; // 110 + BSTArray effectColorControllers; // 128 + BSNiAlphaPropertyTestRefController* alphaRefTestController; // 140 + bool parallax; // 148 + bool parallaxOcclusion; // 149 + bool multiLayerParallax; // 14A + float parallaxOcclusionHeightScale; // 14C + float parallaxOcclusionMaxPasses; // 150 + float parallaxLayerThickness; // 154 + float parallaxRefractionScale; // 158 + float parallaxInnerLayerUScale; // 15C + float parallaxInnerLayerVScale; // 160 + float displacementTextureBias; // 164 + float displacementTextureScale; // 168 + float tessellationPNScale; // 16C + float tessellationFadeDistance; // 170 + float tessellationBaseFactor; // 174 + bool tessellationNeedsDominantUVs; // 178 + bool tessellationNeedsCrackFreeNormals; // 179 + bool environmentMapping; // 17A + bool environmentMappingEye; // 17B + bool environmentMappingWindow; // 17C + float environmentMappingMaskScale; // 180 + std::int32_t skyTYpe; // 184 + bool reflectionsEnabled; // 188 + bool silhouetteReflectionsEnabled; // 189 + bool refractionsEnabled; // 18A + bool depthEnabled; // 18B + bool vertexUVEnabled; // 18C + bool vertexAlphaDepthEnabled; // 18D + bool foggingEnabled; // 18E + bool falloffEnabled; // 18F + bool rgbFalloffEnabled; // 190 + NiColorA falloffData; // 194 + bool softEnabled; // 1A4 + float softDepth; // 1A8 + NiPoint2 uvOffset; // 1AC + NiPoint2 uvScale; // 1B4 + bool grayscaleToPaletteColor; // 1BC + bool grayscaleToPaletteAlpha; // 1BD + NiColor hairTintColor; // 1C0 + NiPointer textureSet; // 1D0 + REX::EnumSet clampMode; // 1D8 }; static_assert(sizeof(BSShaderData) == 0x1E0); diff --git a/CommonLibF4/include/RE/Bethesda/BSExtraData.h b/CommonLibF4/include/RE/Bethesda/BSExtraData.h index d0523ce5..d0a0419a 100644 --- a/CommonLibF4/include/RE/Bethesda/BSExtraData.h +++ b/CommonLibF4/include/RE/Bethesda/BSExtraData.h @@ -310,9 +310,9 @@ namespace RE [[nodiscard]] EXTRA_DATA_TYPE GetExtraType() const noexcept { return *type; } // members - BSExtraData* next{ nullptr }; // 08 - std::uint16_t flags{ 0 }; // 10 - stl::enumeration type{ EXTRA_DATA_TYPE::kNone }; // 12 + BSExtraData* next{ nullptr }; // 08 + std::uint16_t flags{ 0 }; // 10 + REX::EnumSet type{ EXTRA_DATA_TYPE::kNone }; // 12 }; static_assert(sizeof(BSExtraData) == 0x18); @@ -619,12 +619,12 @@ namespace RE } // members - BSFixedStringCS displayName; // 18 - BGSMessage* displayNameText; // 20 - TESQuest* ownerQuest; // 28 - stl::enumeration ownerInstance; // 30 - BSTArray>* textPairs; // 38 - std::uint16_t customNameLength; // 40 + BSFixedStringCS displayName; // 18 + BGSMessage* displayNameText; // 20 + TESQuest* ownerQuest; // 28 + REX::EnumSet ownerInstance; // 30 + BSTArray>* textPairs; // 38 + std::uint16_t customNameLength; // 40 }; static_assert(sizeof(ExtraTextDisplayData) == 0x48); diff --git a/CommonLibF4/include/RE/Bethesda/BSGraphics.h b/CommonLibF4/include/RE/Bethesda/BSGraphics.h index 643c1b4a..eb1f1479 100644 --- a/CommonLibF4/include/RE/Bethesda/BSGraphics.h +++ b/CommonLibF4/include/RE/Bethesda/BSGraphics.h @@ -517,50 +517,50 @@ namespace RE } // members - std::uint32_t currentFrame; // 000 - float offsetX; // 004 - float offsetY; // 008 - std::uint32_t currentFrameOffset; // 00C - std::uint32_t previousFrameOffset; // 010 - FogStateType fogState; // 014 - stl::enumeration multiSample; // 074 - std::uint32_t backBufferWidth; // 078 - std::uint32_t backBufferHeight; // 07C - std::uint32_t screenWidth; // 080 - std::uint32_t screenHeight; // 084 - NiRect frameBufferViewport; // 088 - std::uint32_t frameCount; // 098 - std::uint32_t frameID; // 09C - bool insideFrame; // 0A0 - bool letterbox; // 0A1 - bool allowDepthBufferAsTexture; // 0A2 - bool shadows; // 0A3 - bool compiledShaderThisFrame; // 0A4 - stl::enumeration taaState; // 0A8 - std::uint32_t taaDisableCounter; // 0AC - std::uint32_t trijuiceState; // 0B0 - NiPointer defaultTextureBlack; // 0B8 - NiPointer defaultTextureWhite; // 0C0 - NiPointer defaultTextureGrey; // 0C8 - NiPointer defaultHeightMap; // 0D0 - NiPointer defaultReflectionCubeMap; // 0D8 - NiPointer defaultFaceDetailMap; // 0E0 - NiPointer defaultHighFreqNormalMap; // 0E8 - NiPointer defaultTexEffectMap; // 0F0 - NiPointer defaultTextureWhiteNoiseMap; // 0F8 - NiPointer defaultTextureWhiteNoiseMapSmall; // 100 - NiPointer defaultTextureNormalMap; // 108 - NiPointer defaultTextureDiffuseMap; // 110 - NiPointer defaultSplineMap; // 118 - NiPointer defaultTextureDissolvePattern; // 120 - Texture* defaultImagespaceLUT; // 128 - NiPointer rotatedPoissonDiscLookupMap; // 130 - std::uint32_t presentImmediateThreshold; // 138 - std::uint32_t presentFlag; // 13C - BSTArray cameraDataCache; // 140 - CameraStateData cameraState; // 160 - bool commitTexturesOnCreation; // 3B0 - bool immediateTextureLoads; // 3B1 + std::uint32_t currentFrame; // 000 + float offsetX; // 004 + float offsetY; // 008 + std::uint32_t currentFrameOffset; // 00C + std::uint32_t previousFrameOffset; // 010 + FogStateType fogState; // 014 + REX::EnumSet multiSample; // 074 + std::uint32_t backBufferWidth; // 078 + std::uint32_t backBufferHeight; // 07C + std::uint32_t screenWidth; // 080 + std::uint32_t screenHeight; // 084 + NiRect frameBufferViewport; // 088 + std::uint32_t frameCount; // 098 + std::uint32_t frameID; // 09C + bool insideFrame; // 0A0 + bool letterbox; // 0A1 + bool allowDepthBufferAsTexture; // 0A2 + bool shadows; // 0A3 + bool compiledShaderThisFrame; // 0A4 + REX::EnumSet taaState; // 0A8 + std::uint32_t taaDisableCounter; // 0AC + std::uint32_t trijuiceState; // 0B0 + NiPointer defaultTextureBlack; // 0B8 + NiPointer defaultTextureWhite; // 0C0 + NiPointer defaultTextureGrey; // 0C8 + NiPointer defaultHeightMap; // 0D0 + NiPointer defaultReflectionCubeMap; // 0D8 + NiPointer defaultFaceDetailMap; // 0E0 + NiPointer defaultHighFreqNormalMap; // 0E8 + NiPointer defaultTexEffectMap; // 0F0 + NiPointer defaultTextureWhiteNoiseMap; // 0F8 + NiPointer defaultTextureWhiteNoiseMapSmall; // 100 + NiPointer defaultTextureNormalMap; // 108 + NiPointer defaultTextureDiffuseMap; // 110 + NiPointer defaultSplineMap; // 118 + NiPointer defaultTextureDissolvePattern; // 120 + Texture* defaultImagespaceLUT; // 128 + NiPointer rotatedPoissonDiscLookupMap; // 130 + std::uint32_t presentImmediateThreshold; // 138 + std::uint32_t presentFlag; // 13C + BSTArray cameraDataCache; // 140 + CameraStateData cameraState; // 160 + bool commitTexturesOnCreation; // 3B0 + bool immediateTextureLoads; // 3B1 }; static_assert(sizeof(State) == 0x3C0); diff --git a/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h b/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h index bfa6e923..b192dca2 100644 --- a/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h +++ b/CommonLibF4/include/RE/Bethesda/BSInputDeviceManager.h @@ -31,7 +31,7 @@ namespace RE virtual void ClearInputState() = 0; // 05 // members - stl::enumeration deviceType; // 08 + REX::EnumSet deviceType; // 08 std::int32_t deviceID; // 0C BSTHashMap deviceButtons; // 10 BSTHashMap buttonNameIDMap; // 40 diff --git a/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h b/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h index 1fa05f0d..6fa3ef6a 100644 --- a/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h +++ b/CommonLibF4/include/RE/Bethesda/BSInputEnableManager.h @@ -70,8 +70,8 @@ namespace RE { public: // members - stl::enumeration inputUserEvents; // 00 - stl::enumeration otherInputEvents; // 04 + REX::EnumSet inputUserEvents; // 00 + REX::EnumSet otherInputEvents; // 04 }; static_assert(sizeof(EnableLayer) == 0x08); @@ -130,16 +130,16 @@ namespace RE } // members - BSSpinLock cacheLock; // 110 - stl::enumeration cachedInputUserEventsFlags; // 118 - stl::enumeration cachedOtherInputEventsFlags; // 11C - stl::enumeration forceEnableInputUserEventsFlags; // 120 - stl::enumeration forceOtherInputEventsFlags; // 124 - BSSpinLock layerLock; // 128 - BSTArray layers; // 130 - BSTArray> layerWrappers; // 148 - BSTArray debugNames; // 160 - bool isCurrentlyInSaveLoad; // 178 + BSSpinLock cacheLock; // 110 + REX::EnumSet cachedInputUserEventsFlags; // 118 + REX::EnumSet cachedOtherInputEventsFlags; // 11C + REX::EnumSet forceEnableInputUserEventsFlags; // 120 + REX::EnumSet forceOtherInputEventsFlags; // 124 + BSSpinLock layerLock; // 128 + BSTArray layers; // 130 + BSTArray> layerWrappers; // 148 + BSTArray debugNames; // 160 + bool isCurrentlyInSaveLoad; // 178 }; static_assert(sizeof(BSInputEnableManager) == 0x180); } diff --git a/CommonLibF4/include/RE/Bethesda/BSMTAManager.h b/CommonLibF4/include/RE/Bethesda/BSMTAManager.h index 4beba468..55d54ff9 100644 --- a/CommonLibF4/include/RE/Bethesda/BSMTAManager.h +++ b/CommonLibF4/include/RE/Bethesda/BSMTAManager.h @@ -153,11 +153,11 @@ namespace RE { public: // members - BSBatchRenderer* batchRenderer; // 00 - BSRenderPass* renderPass; // 08 - BSBatchRenderer::GeometryGroup* geometryGroup; // 10 - stl::enumeration group; // 18 - bool addToFront; // 1C + BSBatchRenderer* batchRenderer; // 00 + BSRenderPass* renderPass; // 08 + BSBatchRenderer::GeometryGroup* geometryGroup; // 10 + REX::EnumSet group; // 18 + bool addToFront; // 1C }; static_assert(sizeof(RegisterGeometryGroupPassTask) == 0x20); diff --git a/CommonLibF4/include/RE/Bethesda/BSModelDB.h b/CommonLibF4/include/RE/Bethesda/BSModelDB.h index 432f3a54..564d2119 100644 --- a/CommonLibF4/include/RE/Bethesda/BSModelDB.h +++ b/CommonLibF4/include/RE/Bethesda/BSModelDB.h @@ -33,14 +33,14 @@ namespace RE { public: // members - stl::enumeration lodFadeMult; // 00 - std::uint32_t loadLevel; // 04 - std::uint8_t prepareAfterLoad: 1; // 08:00 - std::uint8_t faceGenModel: 1; // 08:01 - std::uint8_t useErrorMarker: 1; // 08:02 - std::uint8_t performProcess: 1; // 08:03 - std::uint8_t createFadeNode: 1; // 08:04 - std::uint8_t loadTextures: 1; // 08:05 + REX::EnumSet lodFadeMult; // 00 + std::uint32_t loadLevel; // 04 + std::uint8_t prepareAfterLoad: 1; // 08:00 + std::uint8_t faceGenModel: 1; // 08:01 + std::uint8_t useErrorMarker: 1; // 08:02 + std::uint8_t performProcess: 1; // 08:03 + std::uint8_t createFadeNode: 1; // 08:04 + std::uint8_t loadTextures: 1; // 08:05 }; static_assert(sizeof(ArgsType) == 0x0C); diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/CodeTasklet.h b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/CodeTasklet.h index f9e65d8e..ece37333 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/CodeTasklet.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/CodeTasklet.h @@ -93,20 +93,20 @@ namespace RE BSScrapArray& a_args) const override; // 01 // members - Stack* stack; // 10 - VirtualMachine* vm; // 18 - ErrorLogger* errorLogger; // 20 - stl::enumeration resumeReason; // 28 - std::uint32_t pad2C; // 2C - StackFrame* topFrame; // 30 - std::uint32_t frameMemoryPage; // 38 - std::int8_t jumpBitCount; // 3C - std::int8_t localVarBitCount; // 3D - std::int8_t memberVarBitCount; // 3E - std::uint8_t pad3F; // 3F - std::uint32_t instructionDataBitCount; // 40 - std::uint32_t pad44; // 44 - const void* instructionDataStart; // 48 + Stack* stack; // 10 + VirtualMachine* vm; // 18 + ErrorLogger* errorLogger; // 20 + REX::EnumSet resumeReason; // 28 + std::uint32_t pad2C; // 2C + StackFrame* topFrame; // 30 + std::uint32_t frameMemoryPage; // 38 + std::int8_t jumpBitCount; // 3C + std::int8_t localVarBitCount; // 3D + std::int8_t memberVarBitCount; // 3E + std::uint8_t pad3F; // 3F + std::uint32_t instructionDataBitCount; // 40 + std::uint32_t pad44; // 44 + const void* instructionDataStart; // 48 }; static_assert(sizeof(CodeTasklet) == 0x50); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ReadableStringTable.h b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ReadableStringTable.h index e2c11f2f..6786258c 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ReadableStringTable.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ReadableStringTable.h @@ -48,7 +48,7 @@ namespace RE // members msvc::unique_ptr> scrapPages; // 00 msvc::unique_ptr> entries; // 08 - stl::enumeration indexSize; // 10 + REX::EnumSet indexSize; // 10 }; static_assert(sizeof(ReadableStringTable) == 0x18); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ScriptFunction.h b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ScriptFunction.h index 6a71ab18..acc9b217 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ScriptFunction.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/ScriptFunction.h @@ -45,23 +45,23 @@ namespace RE virtual void SetCallableFromTasklets(bool a_taskletCallable) override; // 14 - { return; } // members - BSFixedString name; // 10 - BSFixedString objName; // 18 - BSFixedString stateName; // 20 - TypeInfo retType; // 28 - VDescTable descTable; // 30 - std::uint32_t userFlags; // 40 - std::uint32_t pad44; // 44 - ByteCode::PackedInstructionStream instructions; // 48 - stl::enumeration functionType; // 58 - bool isStatic; // 5A - std::uint8_t pad5B; // 5B - std::uint32_t pad5C; // 5C - BSFixedString docString; // 60 - BSFixedString sourceFileName; // 68 - std::uint32_t lineNumberCount; // 70 - std::uint32_t pad74; // 74 - std::uint16_t* lineNumbers; // 78 + BSFixedString name; // 10 + BSFixedString objName; // 18 + BSFixedString stateName; // 20 + TypeInfo retType; // 28 + VDescTable descTable; // 30 + std::uint32_t userFlags; // 40 + std::uint32_t pad44; // 44 + ByteCode::PackedInstructionStream instructions; // 48 + REX::EnumSet functionType; // 58 + bool isStatic; // 5A + std::uint8_t pad5B; // 5B + std::uint32_t pad5C; // 5C + BSFixedString docString; // 60 + BSFixedString sourceFileName; // 68 + std::uint32_t lineNumberCount; // 70 + std::uint32_t pad74; // 74 + std::uint16_t* lineNumbers; // 78 }; static_assert(sizeof(ScriptFunction) == 0x80); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/VirtualMachine.h b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/VirtualMachine.h index 9d04514b..17040635 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/VirtualMachine.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/VirtualMachine.h @@ -278,7 +278,7 @@ namespace RE BSTArray> pendingLatentReturns; // BDD0 BSTSmartPointer frozenStacksHead; // BDE8 std::uint32_t frozenStacksCount; // BDF0 - stl::enumeration freezeState; // BDF4 + REX::EnumSet freezeState; // BDF4 mutable BSSpinLock attachedScriptsLock; // BDF8 BSTHashMap> attachedScripts; // BE00 std::uint32_t nextObjectToClean; // BE30 diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/WritableStringTable.h b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/WritableStringTable.h index 3f8c11a7..9eeb6378 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Internal/WritableStringTable.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Internal/WritableStringTable.h @@ -18,7 +18,7 @@ namespace RE // members msvc::unique_ptr> stringTable; // 00 msvc::unique_ptr> stringReferenceMap; // 08 - stl::enumeration indexSize; // 10 + REX::EnumSet indexSize; // 10 }; static_assert(sizeof(WritableStringTable) == 0x18); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/PropertyTypeInfo.h b/CommonLibF4/include/RE/Bethesda/BSScript/PropertyTypeInfo.h index 2fe3be06..2ddfa650 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/PropertyTypeInfo.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/PropertyTypeInfo.h @@ -18,16 +18,16 @@ namespace RE }; // members - BSFixedString parentObjName; // 00 - BSFixedString propertyName; // 08 - TypeInfo type; // 10 - stl::enumeration permissions; // 18 - std::uint32_t pad1C; // 1C - BSTSmartPointer getFunction; // 20 - BSTSmartPointer setFunction; // 28 - std::uint32_t autoVarIndex; // 30 - std::uint32_t userFlags; // 34 - BSFixedString docString; // 38 + BSFixedString parentObjName; // 00 + BSFixedString propertyName; // 08 + TypeInfo type; // 10 + REX::EnumSet permissions; // 18 + std::uint32_t pad1C; // 1C + BSTSmartPointer getFunction; // 20 + BSTSmartPointer setFunction; // 28 + std::uint32_t autoVarIndex; // 30 + std::uint32_t userFlags; // 34 + BSFixedString docString; // 38 }; static_assert(sizeof(PropertyTypeInfo) == 0x40); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h b/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h index ef67d410..50811144 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/Stack.h @@ -90,20 +90,20 @@ namespace RE } // members - IMemoryPagePolicy* policy; // 08 - IProfilePolicy* profilePolicy; // 10 - BSTSmallArray pages; // 18 - std::uint32_t frames; // 58 - StackFrame* top; // 60 - stl::enumeration state; // 68 - stl::enumeration freezeState; // 6C - Variable returnValue; // 70 - std::uint32_t stackID; // 80 - stl::enumeration stackType; // 84 - BSTSmartPointer owningTasklet; // 88 - BSTSmartPointer callback; // 90 - BSTSmartPointer objToUnbind; // 98 - BSTSmartPointer nextStack; // A0 + IMemoryPagePolicy* policy; // 08 + IProfilePolicy* profilePolicy; // 10 + BSTSmallArray pages; // 18 + std::uint32_t frames; // 58 + StackFrame* top; // 60 + REX::EnumSet state; // 68 + REX::EnumSet freezeState; // 6C + Variable returnValue; // 70 + std::uint32_t stackID; // 80 + REX::EnumSet stackType; // 84 + BSTSmartPointer owningTasklet; // 88 + BSTSmartPointer callback; // 90 + BSTSmartPointer objToUnbind; // 98 + BSTSmartPointer nextStack; // A0 }; static_assert(sizeof(Stack) == 0xA8); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h b/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h index aacf54dd..3e1f19d7 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/StructTypeInfo.h @@ -59,11 +59,11 @@ namespace RE virtual TypeInfo::RawType GetRawType() const override; // members - BSFixedString name; // 10 - BSTSmartPointer containingObjTypeInfo; // 18 - BSTArray variables; // 20 - BSTHashMap varNameIndexMap; // 38 - stl::enumeration linkedValid; // 68 + BSFixedString name; // 10 + BSTSmartPointer containingObjTypeInfo; // 18 + BSTArray variables; // 20 + BSTHashMap varNameIndexMap; // 38 + REX::EnumSet linkedValid; // 68 }; static_assert(sizeof(StructTypeInfo) == 0x70); } diff --git a/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h b/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h index 35f34601..c0e7eba5 100644 --- a/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h +++ b/CommonLibF4/include/RE/Bethesda/BSScript/TypeInfo.h @@ -140,7 +140,7 @@ namespace RE ~D() noexcept { complexTypeInfo = nullptr; } - stl::enumeration rawType; + REX::EnumSet rawType; IComplexType* complexTypeInfo; } data; // 0 }; diff --git a/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h b/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h index c3dfd3c5..5a62d2c5 100644 --- a/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h +++ b/CommonLibF4/include/RE/Bethesda/BSShaderProperty.h @@ -150,17 +150,17 @@ namespace RE } // members - float alpha; // 28 - std::int32_t lastRenderPassState; // 2C - stl::enumeration flags; // 30 - RenderPassArray renderPassList; // 38 - RenderPassArray debugRenderPassList; // 40 - BSFadeNode* fadeNode; // 48 - BSEffectShaderData* effectData; // 50 - BSShaderMaterial* material; // 58 - std::uint32_t lastAccumTime; // 60 - float lodFade; // 64 - BSNonReentrantSpinLock clearRenderPassesLock; // 68 + float alpha; // 28 + std::int32_t lastRenderPassState; // 2C + REX::EnumSet flags; // 30 + RenderPassArray renderPassList; // 38 + RenderPassArray debugRenderPassList; // 40 + BSFadeNode* fadeNode; // 48 + BSEffectShaderData* effectData; // 50 + BSShaderMaterial* material; // 58 + std::uint32_t lastAccumTime; // 60 + float lodFade; // 64 + BSNonReentrantSpinLock clearRenderPassesLock; // 68 }; static_assert(sizeof(BSShaderProperty) == 0x70); diff --git a/CommonLibF4/include/RE/Bethesda/ControlMap.h b/CommonLibF4/include/RE/Bethesda/ControlMap.h index ff3b1733..276abb3a 100644 --- a/CommonLibF4/include/RE/Bethesda/ControlMap.h +++ b/CommonLibF4/include/RE/Bethesda/ControlMap.h @@ -31,12 +31,12 @@ namespace RE { public: // members - BSFixedString eventID; // 00 - std::int32_t inputKey; // 08 - std::int8_t byIndexInContext; // 0C - bool remappable; // 0D - bool linked; // 0E - stl::enumeration userEventGroupFlag; // 10 + BSFixedString eventID; // 00 + std::int32_t inputKey; // 08 + std::int8_t byIndexInContext; // 0C + bool remappable; // 0D + bool linked; // 0E + REX::EnumSet userEventGroupFlag; // 10 }; static_assert(sizeof(UserEventMapping) == 0x18); @@ -52,11 +52,11 @@ namespace RE { public: // members - BSFixedString linkedMappingName; // 00 - stl::enumeration linkedMappingContext; // 08 - stl::enumeration device; // 0C - stl::enumeration linkFromContext; // 10 - BSFixedString linkFromName; // 18 + BSFixedString linkedMappingName; // 00 + REX::EnumSet linkedMappingContext; // 08 + REX::EnumSet device; // 0C + REX::EnumSet linkFromContext; // 10 + BSFixedString linkFromName; // 18 }; static_assert(sizeof(LinkedMapping) == 0x20); @@ -122,13 +122,13 @@ namespace RE void SetIgnoreKeyboardMouse(bool a_value) noexcept { ignoreKeyboardMouse = a_value; } // members - InputContext* controlMaps[std::to_underlying(UserEvents::INPUT_CONTEXT_ID::kTotal)]; // 008 - BSTArray linkedMappings; // 110 - BSTArray> contextPriorityStack; // 128 - std::int8_t byTextEntryCount; // 140 - bool ignoreKeyboardMouse; // 141 - bool ignoreActivateDisabledEvents; // 142 - stl::enumeration pcGamePadMapType; // 144 + InputContext* controlMaps[std::to_underlying(UserEvents::INPUT_CONTEXT_ID::kTotal)]; // 008 + BSTArray linkedMappings; // 110 + BSTArray> contextPriorityStack; // 128 + std::int8_t byTextEntryCount; // 140 + bool ignoreKeyboardMouse; // 141 + bool ignoreActivateDisabledEvents; // 142 + REX::EnumSet pcGamePadMapType; // 144 }; static_assert(sizeof(ControlMap) == 0x148); } diff --git a/CommonLibF4/include/RE/Bethesda/Events.h b/CommonLibF4/include/RE/Bethesda/Events.h index f503ffa2..c3324c41 100644 --- a/CommonLibF4/include/RE/Bethesda/Events.h +++ b/CommonLibF4/include/RE/Bethesda/Events.h @@ -44,10 +44,10 @@ namespace RE struct Event { // members - stl::enumeration changeType; // 00 - const BGSObjectInstance* itemAffected; // 08 - Actor* actorAffected; // 10 - std::uint32_t stackID; // 18 + REX::EnumSet changeType; // 00 + const BGSObjectInstance* itemAffected; // 08 + Actor* actorAffected; // 10 + std::uint32_t stackID; // 18 }; static_assert(sizeof(Event) == 0x20); } @@ -70,8 +70,8 @@ namespace RE }; // members - std::uint32_t cellID; // 04 - stl::enumeration flags; // 08 + std::uint32_t cellID; // 04 + REX::EnumSet flags; // 08 }; static_assert(sizeof(BGSActorCellEvent) == 0xC); @@ -168,8 +168,8 @@ namespace RE }; // members - TESObjectCELL* cell; // 00 - stl::enumeration type; // 08 + TESObjectCELL* cell; // 00 + REX::EnumSet type; // 08 }; static_assert(sizeof(CellAttachDetachEvent) == 0x10); @@ -456,22 +456,22 @@ namespace RE { public: // members - BSTSmallArray itemData; // 00 - ObjectRefHandle containerRef; // 88 - ObjectRefHandle inventoryRef; // 8C - BSFixedStringCS aButtonText; // 90 - BSFixedString containerName; // 98 - BSFixedStringCS perkButtonText; // A0 - std::int32_t selectedClipIndex; // A8 - stl::enumeration mode; // AC - bool perkButtonEnabled; // B0 - bool isNewContainer; // B1 - bool addedDroppedItems; // B2 - bool isLocked; // B3 - bool buttonAEnabled; // B4 - bool buttonXEnabled; // B5 - bool refreshContainerSize; // B6 - bool containerActivated; // B7 + BSTSmallArray itemData; // 00 + ObjectRefHandle containerRef; // 88 + ObjectRefHandle inventoryRef; // 8C + BSFixedStringCS aButtonText; // 90 + BSFixedString containerName; // 98 + BSFixedStringCS perkButtonText; // A0 + std::int32_t selectedClipIndex; // A8 + REX::EnumSet mode; // AC + bool perkButtonEnabled; // B0 + bool isNewContainer; // B1 + bool addedDroppedItems; // B2 + bool isLocked; // B3 + bool buttonAEnabled; // B4 + bool buttonXEnabled; // B5 + bool refreshContainerSize; // B6 + bool containerActivated; // B7 }; static_assert(sizeof(QuickContainerStateData) == 0xB8); @@ -644,9 +644,9 @@ namespace RE } // members - NiPointer actor; // 00 - NiPointer targetFurniture; // 08 - stl::enumeration type; // 10 + NiPointer actor; // 00 + NiPointer targetFurniture; // 08 + REX::EnumSet type; // 10 }; static_assert(sizeof(TESFurnitureEvent) == 0x18); @@ -708,16 +708,16 @@ namespace RE float percentBlocked; // A0 float resistedPhysicalDamage; // A4 float resistedTypedDamage; // A8 - stl::enumeration stagger; // AC + REX::EnumSet stagger; // AC float sneakAttackBonus; // B0 float bonusHealthDamageMult; // B4 float pushBack; // B8 float reflectedDamage; // BC float criticalDamageMult; // C0 - stl::enumeration flags; // C4 + REX::EnumSet flags; // C4 BGSEquipIndex equipIndex; // C8 std::uint32_t material; // D0 - stl::enumeration damageLimb; // D4 + REX::EnumSet damageLimb; // D4 }; static_assert(sizeof(HitData) == 0xE0); @@ -805,9 +805,9 @@ namespace RE { public: // members - stl::enumeration newUserEventFlag; // 0 - stl::enumeration oldUserEventFlag; // 4 - stl::enumeration senderID; // 8 + REX::EnumSet newUserEventFlag; // 0 + REX::EnumSet oldUserEventFlag; // 4 + REX::EnumSet senderID; // 8 }; static_assert(sizeof(UserEventEnabledEvent) == 0xC); diff --git a/CommonLibF4/include/RE/Bethesda/FormComponents.h b/CommonLibF4/include/RE/Bethesda/FormComponents.h index 43daad54..6797bded 100644 --- a/CommonLibF4/include/RE/Bethesda/FormComponents.h +++ b/CommonLibF4/include/RE/Bethesda/FormComponents.h @@ -244,7 +244,7 @@ namespace RE virtual void DoClearDucking() { return; } // 0A // members - stl::enumeration trackStatus; // 08 + REX::EnumSet trackStatus; // 08 }; static_assert(sizeof(BSIMusicTrack) == 0x10); @@ -266,15 +266,15 @@ namespace RE virtual ~BSIMusicType(); // 07 // members - std::uint32_t flags; // 08 - std::int8_t priority; // 0C - std::int8_t padding; // 0D - std::uint16_t ducksOtherMusicBy; // 0E - float fadeTime; // 10 - std::uint32_t currentTrackIndex; // 14 - BSTArray trackHistory; // 18 - BSTArray tracks; // 30 - stl::enumeration typeStatus; // 48 + std::uint32_t flags; // 08 + std::int8_t priority; // 0C + std::int8_t padding; // 0D + std::uint16_t ducksOtherMusicBy; // 0E + float fadeTime; // 10 + std::uint32_t currentTrackIndex; // 14 + BSTArray trackHistory; // 18 + BSTArray tracks; // 30 + REX::EnumSet typeStatus; // 48 }; static_assert(sizeof(BSIMusicType) == 0x50); @@ -1375,9 +1375,9 @@ namespace RE void SetBaseEnchanting(EnchantmentItem* a_ench) noexcept { formEnchanting = a_ench; } // members - EnchantmentItem* formEnchanting; // 08 - stl::enumeration castingType; // 10 - std::uint16_t amountOfEnchantment; // 12 + EnchantmentItem* formEnchanting; // 08 + REX::EnumSet castingType; // 10 + std::uint16_t amountOfEnchantment; // 12 }; static_assert(sizeof(TESEnchantableForm) == 0x18); @@ -1548,14 +1548,14 @@ namespace RE }; // members - stl::enumeration actorBaseFlags; // 00 - std::int16_t xpValueOffset; // 04 - std::uint16_t level; // 06 - std::uint16_t calcLevelMin; // 08 - std::uint16_t calcLevelMax; // 0A - std::uint16_t baseDisposition; // 0C - stl::enumeration templateUseFlags; // 0E - std::int16_t bleedoutOverride; // 10 + REX::EnumSet actorBaseFlags; // 00 + std::int16_t xpValueOffset; // 04 + std::uint16_t level; // 06 + std::uint16_t calcLevelMin; // 08 + std::uint16_t calcLevelMax; // 0A + std::uint16_t baseDisposition; // 0C + REX::EnumSet templateUseFlags; // 0E + std::int16_t bleedoutOverride; // 10 }; static_assert(sizeof(ACTOR_BASE_DATA) == 0x14); diff --git a/CommonLibF4/include/RE/Bethesda/HUDModes.h b/CommonLibF4/include/RE/Bethesda/HUDModes.h index aaf6c6c6..588a13f1 100644 --- a/CommonLibF4/include/RE/Bethesda/HUDModes.h +++ b/CommonLibF4/include/RE/Bethesda/HUDModes.h @@ -10,9 +10,9 @@ namespace RE { public: // members - BSTArray validHUDModes; // 00 - stl::enumeration powerArmorHUDVisibilityRule; // 18 - bool canBeVisible; // 1C + BSTArray validHUDModes; // 00 + REX::EnumSet powerArmorHUDVisibilityRule; // 18 + bool canBeVisible; // 1C }; static_assert(sizeof(HUDModes) == 0x20); } diff --git a/CommonLibF4/include/RE/Bethesda/IMenu.h b/CommonLibF4/include/RE/Bethesda/IMenu.h index 7b8f98b2..7b2d94a4 100644 --- a/CommonLibF4/include/RE/Bethesda/IMenu.h +++ b/CommonLibF4/include/RE/Bethesda/IMenu.h @@ -391,18 +391,18 @@ namespace RE [[nodiscard]] bool UsesCursor() const noexcept { return menuFlags.all(UI_MENU_FLAGS::kUsesCursor); } // members - Scaleform::GFx::Value menuObj; // 20 - Scaleform::Ptr uiMovie; // 40 - BSFixedString customRendererName; // 48 - BSFixedString menuName; // 50 - stl::enumeration menuFlags; // 58 - BSTAtomicValue advanceWithoutRenderCount{ 0 }; // 5C - bool passesTopMenuTest{ true }; // 60 - bool menuCanBeVisible{ true }; // 61 - bool hasQuadsForCumstomRenderer{ false }; // 62 - bool hasDoneFirstAdvanceMovie{ false }; // 63 - stl::enumeration depthPriority{ UI_DEPTH_PRIORITY::kStandard }; // 64 - stl::enumeration inputContext{ UserEvents::INPUT_CONTEXT_ID::kNone }; // 68 + Scaleform::GFx::Value menuObj; // 20 + Scaleform::Ptr uiMovie; // 40 + BSFixedString customRendererName; // 48 + BSFixedString menuName; // 50 + REX::EnumSet menuFlags; // 58 + BSTAtomicValue advanceWithoutRenderCount{ 0 }; // 5C + bool passesTopMenuTest{ true }; // 60 + bool menuCanBeVisible{ true }; // 61 + bool hasQuadsForCumstomRenderer{ false }; // 62 + bool hasDoneFirstAdvanceMovie{ false }; // 63 + REX::EnumSet depthPriority{ UI_DEPTH_PRIORITY::kStandard }; // 64 + REX::EnumSet inputContext{ UserEvents::INPUT_CONTEXT_ID::kNone }; // 68 }; static_assert(sizeof(IMenu) == 0x70); @@ -663,10 +663,10 @@ namespace RE } // members - UIShaderColors shaderFX; // 58 - BSTArray shaderFXObjects; // 90 - stl::enumeration HUDColorType; // A8 - stl::enumeration backgroundColorType; // AC + UIShaderColors shaderFX; // 58 + BSTArray shaderFXObjects; // 90 + REX::EnumSet HUDColorType; // A8 + REX::EnumSet backgroundColorType; // AC private: void ctor_shared() @@ -882,7 +882,7 @@ namespace RE // members BSTSmallArray, 32> hudObjects; // 0F0 BSTArray hudModes; // 200 - stl::enumeration hudShowMenuState; // 218 + REX::EnumSet hudShowMenuState; // 218 }; static_assert(sizeof(HUDMenu) == 0x220); @@ -1463,8 +1463,8 @@ namespace RE } // members - stl::enumeration currentSort[14]; // 00 - std::uint32_t currentTab; // 38 + REX::EnumSet currentSort[14]; // 00 + std::uint32_t currentTab; // 38 }; static_assert(sizeof(ItemSorter) == 0x3C); @@ -1511,7 +1511,7 @@ namespace RE Inventory3DManager inv3DModelManager; // 2A0 BSTArray partialPlayerUpdateList; // 3E0 BSTArray partialContainerUpdateList; // 3F8 - stl::enumeration menuMode; // 410 + REX::EnumSet menuMode; // 410 Rumble::AutoRumblePause autoRumblePause; // 414 DisableHeavyItemsFunc disableHeavyFunc; // 418 ObjectRefHandle containerRef; // 428 @@ -1746,27 +1746,27 @@ namespace RE virtual bool TryCreate() = 0; // 1B // members - NiPointer sharedContainerRef; // 0E0 - NiPointer workbenchContainerRef; // 0E8 - BSTArray> sharedContainers; // 0F0 - Inventory3DManager inv3DModelManager; // 110 - BGSInventoryList optimizedAutoBuildInv; // 250 - BSTArray modChoiceArray; // 2D0 - std::uint32_t modChoiceIndex; // 2E8 - std::uint32_t lastModChoiceIndex; // 2EC - bool repairing; // 2F0 - bool queueHide; // 2F1 - bool hiding; // 2F2 - bool VATSWasEnabled; // 2F3 - NiPointer workbenchRef; // 2F8 - BSTSmartPointer recipeExtraDataList; // 300 - NiPointer item3DGeometry; // 308 - BSTArray queuedCraftingComponents; // 310 - std::uint64_t soundTimer; // 328 - stl::enumeration highlightMode; // 330 - Rumble::AutoRumblePause autoRumblePause; // 334 - bool initialized; // 335 - bool soundsQueued; // 336 + NiPointer sharedContainerRef; // 0E0 + NiPointer workbenchContainerRef; // 0E8 + BSTArray> sharedContainers; // 0F0 + Inventory3DManager inv3DModelManager; // 110 + BGSInventoryList optimizedAutoBuildInv; // 250 + BSTArray modChoiceArray; // 2D0 + std::uint32_t modChoiceIndex; // 2E8 + std::uint32_t lastModChoiceIndex; // 2EC + bool repairing; // 2F0 + bool queueHide; // 2F1 + bool hiding; // 2F2 + bool VATSWasEnabled; // 2F3 + NiPointer workbenchRef; // 2F8 + BSTSmartPointer recipeExtraDataList; // 300 + NiPointer item3DGeometry; // 308 + BSTArray queuedCraftingComponents; // 310 + std::uint64_t soundTimer; // 328 + REX::EnumSet highlightMode; // 330 + Rumble::AutoRumblePause autoRumblePause; // 334 + bool initialized; // 335 + bool soundsQueued; // 336 }; static_assert(sizeof(WorkbenchMenuBase) == 0x340); @@ -1829,10 +1829,10 @@ namespace RE F4_HEAP_REDEFINE_NEW(InitData); // members - BSFixedString confirmQuestion; // 08 - BSFixedStringCS buttonLabel; // 10 - stl::enumeration confirmType{ CONFIRM_TYPE::kSimple }; // 18 - bool hasCancelButton{ true }; // 1C + BSFixedString confirmQuestion; // 08 + BSFixedStringCS buttonLabel; // 10 + REX::EnumSet confirmType{ CONFIRM_TYPE::kSimple }; // 18 + bool hasCancelButton{ true }; // 1C }; static_assert(sizeof(InitData) == 0x20); @@ -1995,50 +1995,50 @@ namespace RE } // members - ComponentBuilderFunctor componentFunctor; // 340 - stl::enumeration inspectModeState; // 368 - ObjectRefHandle inventorySource; // 36C - InventoryUserUIInterface invInterface; // 370 - InventoryInterface::Handle modItem; // 3F0 - std::uint32_t modStack; // 3F4 - BSTHashMap scrappableItemsMap; // 3F8 - BSTArray> scrappingArray; // 420 - BSTArray> slotObjects; // 440 - BSTSmartPointer extraDataList; // 458 - std::uint32_t slotObjectIndex; // 460 - Scaleform::GFx::Value buttonAnimBase; // 468 - Scaleform::GFx::Value itemList; // 488 - Scaleform::GFx::Value itemNameTextField; // 4A8 - Scaleform::GFx::Value itemInfoList; // 4C8 - Scaleform::GFx::Value modChoiceList; // 4E8 - Scaleform::GFx::Value modSlotList; // 508 - Scaleform::GFx::Value currentModsList; // 528 - BGSInventoryItem moddedInventoryItem; // 548 - bool queueItemHighlight; // 558 - float zoomDistance; // 55C - float lastFrameDelta; // 560 - float menuCursorLeftPct; // 564 - float menuCursorRightPct; // 568 - float menuCursorTopPct; // 56C - float menuCursorBottomPct; // 570 - BSTArray queuedSoundArray; // 578 - std::byte attachPointSource3D[0x598 - 0x590]; // 590 - TODO - const BGSMod::Attachment::Mod* nullMod; // 598 - Scaleform::GFx::Value requirementsList; // 5A0 - Scaleform::GFx::Value itemSelectList; // 5C0 - const BGSKeyword* keyword; // 5E0 - bool queueChangeCameraPosition; // 5E8 - bool returnToInspect; // 5E9 - bool highlightStoredItem; // 5EA - bool textEntry; // 5EB - bool virtualKeyboardPendingEvt; // 5EC - bool inspectMode; // 5ED - bool inspectingSingleItem; // 5EE - bool inspectingFeaturedItem; // 5EF - bool showFeaturedItemMessage; // 5F0 - char renameItemTo[260]; // 5F1 - char renameItemCancelState[260]; // 6F5 - BSTSmartPointer inputLayer; // 800 + ComponentBuilderFunctor componentFunctor; // 340 + REX::EnumSet inspectModeState; // 368 + ObjectRefHandle inventorySource; // 36C + InventoryUserUIInterface invInterface; // 370 + InventoryInterface::Handle modItem; // 3F0 + std::uint32_t modStack; // 3F4 + BSTHashMap scrappableItemsMap; // 3F8 + BSTArray> scrappingArray; // 420 + BSTArray> slotObjects; // 440 + BSTSmartPointer extraDataList; // 458 + std::uint32_t slotObjectIndex; // 460 + Scaleform::GFx::Value buttonAnimBase; // 468 + Scaleform::GFx::Value itemList; // 488 + Scaleform::GFx::Value itemNameTextField; // 4A8 + Scaleform::GFx::Value itemInfoList; // 4C8 + Scaleform::GFx::Value modChoiceList; // 4E8 + Scaleform::GFx::Value modSlotList; // 508 + Scaleform::GFx::Value currentModsList; // 528 + BGSInventoryItem moddedInventoryItem; // 548 + bool queueItemHighlight; // 558 + float zoomDistance; // 55C + float lastFrameDelta; // 560 + float menuCursorLeftPct; // 564 + float menuCursorRightPct; // 568 + float menuCursorTopPct; // 56C + float menuCursorBottomPct; // 570 + BSTArray queuedSoundArray; // 578 + std::byte attachPointSource3D[0x598 - 0x590]; // 590 - TODO + const BGSMod::Attachment::Mod* nullMod; // 598 + Scaleform::GFx::Value requirementsList; // 5A0 + Scaleform::GFx::Value itemSelectList; // 5C0 + const BGSKeyword* keyword; // 5E0 + bool queueChangeCameraPosition; // 5E8 + bool returnToInspect; // 5E9 + bool highlightStoredItem; // 5EA + bool textEntry; // 5EB + bool virtualKeyboardPendingEvt; // 5EC + bool inspectMode; // 5ED + bool inspectingSingleItem; // 5EE + bool inspectingFeaturedItem; // 5EF + bool showFeaturedItemMessage; // 5F0 + char renameItemTo[260]; // 5F1 + char renameItemCancelState[260]; // 6F5 + BSTSmartPointer inputLayer; // 800 }; static_assert(sizeof(ExamineMenu) == 0x810); @@ -2288,7 +2288,7 @@ namespace RE BSTSmartPointer terminalRunResultsCallback; // 218 BSScaleformExternalTexture displayImage; // 220 BSSoundHandle charScrollLoop; // 238 - stl::enumeration mode; // 240 + REX::EnumSet mode; // 240 std::uint64_t soundMark; // 248 std::uint64_t responseTextTimeout; // 250 std::uint64_t loginTextTimeout; // 258 diff --git a/CommonLibF4/include/RE/Bethesda/InputEvent.h b/CommonLibF4/include/RE/Bethesda/InputEvent.h index abd2dd99..bec9573c 100644 --- a/CommonLibF4/include/RE/Bethesda/InputEvent.h +++ b/CommonLibF4/include/RE/Bethesda/InputEvent.h @@ -218,12 +218,12 @@ namespace RE } // members - stl::enumeration device{ INPUT_DEVICE::kNone }; // 08 - std::int32_t deviceID{ 0 }; // 0C - stl::enumeration eventType{ INPUT_EVENT_TYPE::kNone }; // 10 - InputEvent* next{ nullptr }; // 18 - std::uint32_t timeCode{ static_cast(-1) }; // 20 - stl::enumeration handled{ HANDLED_RESULT::kUnhandled }; // 24 + REX::EnumSet device{ INPUT_DEVICE::kNone }; // 08 + std::int32_t deviceID{ 0 }; // 0C + REX::EnumSet eventType{ INPUT_EVENT_TYPE::kNone }; // 10 + InputEvent* next{ nullptr }; // 18 + std::uint32_t timeCode{ static_cast(-1) }; // 20 + REX::EnumSet handled{ HANDLED_RESULT::kUnhandled }; // 24 }; static_assert(sizeof(InputEvent) == 0x28); @@ -314,7 +314,7 @@ namespace RE [[nodiscard]] BS_BUTTON_CODE GetBSButtonCode() const noexcept { - stl::enumeration result{ static_cast(idCode) }; + REX::EnumSet result{ static_cast(idCode) }; switch (device.get()) { case INPUT_DEVICE::kGamepad: result.set(BS_BUTTON_CODE::kGamepad); diff --git a/CommonLibF4/include/RE/Bethesda/Interface3D.h b/CommonLibF4/include/RE/Bethesda/Interface3D.h index f85a5a92..43614d96 100644 --- a/CommonLibF4/include/RE/Bethesda/Interface3D.h +++ b/CommonLibF4/include/RE/Bethesda/Interface3D.h @@ -113,11 +113,11 @@ namespace RE { public: // members - stl::enumeration type; // 00 - float spotFOV; // 04 - NiPoint3 lookAtPos; // 08 - NiPointer lookAtObject; // 18 - NiPointer light; // 20 + REX::EnumSet type; // 00 + float spotFOV; // 04 + NiPoint3 lookAtPos; // 08 + NiPointer lookAtObject; // 18 + NiPointer light; // 20 }; static_assert(sizeof(LightParams) == 0x28); @@ -385,62 +385,62 @@ namespace RE } // members - BSTAlignedArray colorFXInfos; // 000 - BSTAlignedArray backgroundFXInfos; // 018 - BSReadWriteLock cachedQuadsLock; // 030 - NiColorA clearColor; // 038 - float opacityAlpha; // 048 - bool enabled; // 04C - bool offscreen3DEnabled; // 04D - bool hideScreenWhenDisabled; // 04E - bool usePremultAlpha; // 04F - bool clearRenderTarget; // 050 - bool clearDepthStencilMainScreen; // 051 - bool clearDepthStencilOffscreen; // 052 - bool postAA; // 053 - bool useFullPremultAlpha; // 054 - bool alwaysRenderWhenEnabled; // 055 - bool defRenderMainScreen; // 056 - bool enableAO; // 057 - bool useLongRangeCamera; // 058 - bool needsLightSetup; // 059 - bool needsLightSetupOffscreen; // 05A - stl::enumeration bgmode; // 05C - stl::enumeration postfx; // 060 - stl::enumeration highlightfx; // 064 - stl::enumeration omsize; // 068 - stl::enumeration screenmode; // 06C - stl::enumeration menuBlend; // 070 - stl::enumeration depth; // 074 - NiPointer worldAttachedElementRoot; // 078 - NiPointer screenAttachedElementRoot; // 080 - NiPointer offscreenElement; // 088 - BSTArray> displayGeometry; // 090 - NiAVObject* elementRequiringFullVieport; // 0A8 - NiAVObject* highlightedElement; // 0B0 - bool highlightOffscreen; // 0B8 - OldScreenEffectControl pipfx; // 0BC - OldScreenEffectControl vatsfx; // 12C - NiPointer accum; // 1A0 - NiPointer pipboyAspect; // 1A8 - NiPointer nativeAspect; // 1B0 - NiPointer nativeAspectLongRange; // 1B8 - std::int32_t customRenderTarget; // 1C0 - std::int32_t customSwapTarget; // 1C4 - BSTArray mainLights; // 1C8 - BSTArray offscreenLights; // 1E0 - float menuDiffuseIntensity; // 1F8 - float menuEmitIntensity; // 1FC - float menuDiffuseIntensityWA; // 200 - float menuEmitIntensityWA; // 204 - BSFixedString name; // 208 - BSFixedString screenGeomName; // 210 - BSFixedString screenMaterialName; // 218 - BSFixedString maskedGeomName; // 220 - BSFixedString maskedMaterialName; // 228 - NiDirectionalLight* directionalLight; // 230 - NiPointer screenSSN; // 238 - NiPointer offscreenSSN; // 240 + BSTAlignedArray colorFXInfos; // 000 + BSTAlignedArray backgroundFXInfos; // 018 + BSReadWriteLock cachedQuadsLock; // 030 + NiColorA clearColor; // 038 + float opacityAlpha; // 048 + bool enabled; // 04C + bool offscreen3DEnabled; // 04D + bool hideScreenWhenDisabled; // 04E + bool usePremultAlpha; // 04F + bool clearRenderTarget; // 050 + bool clearDepthStencilMainScreen; // 051 + bool clearDepthStencilOffscreen; // 052 + bool postAA; // 053 + bool useFullPremultAlpha; // 054 + bool alwaysRenderWhenEnabled; // 055 + bool defRenderMainScreen; // 056 + bool enableAO; // 057 + bool useLongRangeCamera; // 058 + bool needsLightSetup; // 059 + bool needsLightSetupOffscreen; // 05A + REX::EnumSet bgmode; // 05C + REX::EnumSet postfx; // 060 + REX::EnumSet highlightfx; // 064 + REX::EnumSet omsize; // 068 + REX::EnumSet screenmode; // 06C + REX::EnumSet menuBlend; // 070 + REX::EnumSet depth; // 074 + NiPointer worldAttachedElementRoot; // 078 + NiPointer screenAttachedElementRoot; // 080 + NiPointer offscreenElement; // 088 + BSTArray> displayGeometry; // 090 + NiAVObject* elementRequiringFullVieport; // 0A8 + NiAVObject* highlightedElement; // 0B0 + bool highlightOffscreen; // 0B8 + OldScreenEffectControl pipfx; // 0BC + OldScreenEffectControl vatsfx; // 12C + NiPointer accum; // 1A0 + NiPointer pipboyAspect; // 1A8 + NiPointer nativeAspect; // 1B0 + NiPointer nativeAspectLongRange; // 1B8 + std::int32_t customRenderTarget; // 1C0 + std::int32_t customSwapTarget; // 1C4 + BSTArray mainLights; // 1C8 + BSTArray offscreenLights; // 1E0 + float menuDiffuseIntensity; // 1F8 + float menuEmitIntensity; // 1FC + float menuDiffuseIntensityWA; // 200 + float menuEmitIntensityWA; // 204 + BSFixedString name; // 208 + BSFixedString screenGeomName; // 210 + BSFixedString screenMaterialName; // 218 + BSFixedString maskedGeomName; // 220 + BSFixedString maskedMaterialName; // 228 + NiDirectionalLight* directionalLight; // 230 + NiPointer screenSSN; // 238 + NiPointer offscreenSSN; // 240 }; static_assert(sizeof(Renderer) == 0x248); } diff --git a/CommonLibF4/include/RE/Bethesda/MagicItems.h b/CommonLibF4/include/RE/Bethesda/MagicItems.h index a5448222..a8c415cf 100644 --- a/CommonLibF4/include/RE/Bethesda/MagicItems.h +++ b/CommonLibF4/include/RE/Bethesda/MagicItems.h @@ -126,13 +126,13 @@ namespace RE { public: // members - stl::enumeration castingType; // 08 - std::int32_t chargeOverride; // 0C - stl::enumeration delivery; // 10 - stl::enumeration spellType; // 14 - float chargeTime; // 18 - EnchantmentItem* baseEnchantment; // 20 - BGSListForm* wornRestrictions; // 28 + REX::EnumSet castingType; // 08 + std::int32_t chargeOverride; // 0C + REX::EnumSet delivery; // 10 + REX::EnumSet spellType; // 14 + float chargeTime; // 18 + EnchantmentItem* baseEnchantment; // 20 + BGSListForm* wornRestrictions; // 28 }; static_assert(sizeof(Data) == 0x30); @@ -157,13 +157,13 @@ namespace RE { public: // members - stl::enumeration spellType; // 08 - float chargeTime; // 0C - stl::enumeration castingType; // 10 - stl::enumeration delivery; // 14 - float castDuration; // 18 - float range; // 1C - BGSPerk* castingPerk; // 20 + REX::EnumSet spellType; // 08 + float chargeTime; // 0C + REX::EnumSet castingType; // 10 + REX::EnumSet delivery; // 14 + float castDuration; // 18 + float range; // 1C + BGSPerk* castingPerk; // 20 }; static_assert(sizeof(Data) == 0x28); diff --git a/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h b/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h index b7c0cbb5..03202f71 100644 --- a/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h +++ b/CommonLibF4/include/RE/Bethesda/MessageMenuManager.h @@ -71,14 +71,14 @@ namespace RE static constexpr auto VTABLE{ VTABLE::MessageBoxData }; // members - BSStringT headerText; // 18 - BSStringT bodyText; // 28 - BSTArray> buttonText; // 38 - stl::enumeration warningContext; // 50 - BSTSmartPointer callback; // 58 - stl::enumeration menuDepth; // 60 - bool modal; // 64 - bool ensureUnique; // 65 + BSStringT headerText; // 18 + BSStringT bodyText; // 28 + BSTArray> buttonText; // 38 + REX::EnumSet warningContext; // 50 + BSTSmartPointer callback; // 58 + REX::EnumSet menuDepth; // 60 + bool modal; // 64 + bool ensureUnique; // 65 }; static_assert(sizeof(MessageBoxData) == 0x68); @@ -109,10 +109,10 @@ namespace RE } // members - BSReadWriteLock messageRWLock; // 04 - BSTArray messages; // 10 - stl::enumeration currentWarningContext; // 28 - bool disabledWarnings[34]; // 2C + BSReadWriteLock messageRWLock; // 04 + BSTArray messages; // 10 + REX::EnumSet currentWarningContext; // 28 + bool disabledWarnings[34]; // 2C }; static_assert(sizeof(MessageMenuManager) == 0x50); } diff --git a/CommonLibF4/include/RE/Bethesda/NavMesh.h b/CommonLibF4/include/RE/Bethesda/NavMesh.h index 540c3379..bdc4bd25 100644 --- a/CommonLibF4/include/RE/Bethesda/NavMesh.h +++ b/CommonLibF4/include/RE/Bethesda/NavMesh.h @@ -54,8 +54,8 @@ namespace RE { public: // members - stl::enumeration type; // 0 - BSNavmeshTriangleEdgePortal portal; // 4 + REX::EnumSet type; // 0 + BSNavmeshTriangleEdgePortal portal; // 4 }; static_assert(sizeof(BSNavmeshEdgeExtraInfo) == 0xC); diff --git a/CommonLibF4/include/RE/Bethesda/PipboyManager.h b/CommonLibF4/include/RE/Bethesda/PipboyManager.h index de760cb0..3d716339 100644 --- a/CommonLibF4/include/RE/Bethesda/PipboyManager.h +++ b/CommonLibF4/include/RE/Bethesda/PipboyManager.h @@ -242,33 +242,33 @@ namespace RE } // members - BSSoundHandle pipboyHumSound; // 01C - BSTPoint2 inputVector; // 024 - BSTPoint2 newInput; // 02C - NiPointer debugModeGeom; // 038 - Inventory3DManager inv3DModelManager; // 040 - BGSNote* holotapeToLoad; // 180 - BGSTerminal* terminalToLoad; // 188 - BSFixedString menuToOpen; // 190 - BSFixedString openAnimEvent; // 198 - BSFixedString closeAnimEvent; // 1A0 - stl::enumeration loweringReason; // 1A8 - PipboyRadioController radioController; // 1AC - TESBoundObject* itemAnimOnClose; // 1B0 - ObjectRefHandle fastTravelLocation; // 1B8 - InventoryInterface::Handle inspectRequestItem; // 1BC - std::uint32_t inspectRequestStack; // 1C0 - bool pipboyExamineMode; // 1C4 - bool pipboyExamineDirtyFlag; // 1C5 - bool pipboyOpening; // 1C6 - bool pipboyClosing; // 1C7 - BSTValueEventSource pipboyActive; // 1C8 - bool ignoreOpeningFlag; // 1E0 - bool autoSaveOnClose; // 1E1 - bool pipboyMenuCloseQueued; // 1E2 - bool pipboyRaising; // 1E3 - bool wasMotionBlurActive; // 1E4 - bool wasPipboyLightActive; // 1E5 + BSSoundHandle pipboyHumSound; // 01C + BSTPoint2 inputVector; // 024 + BSTPoint2 newInput; // 02C + NiPointer debugModeGeom; // 038 + Inventory3DManager inv3DModelManager; // 040 + BGSNote* holotapeToLoad; // 180 + BGSTerminal* terminalToLoad; // 188 + BSFixedString menuToOpen; // 190 + BSFixedString openAnimEvent; // 198 + BSFixedString closeAnimEvent; // 1A0 + REX::EnumSet loweringReason; // 1A8 + PipboyRadioController radioController; // 1AC + TESBoundObject* itemAnimOnClose; // 1B0 + ObjectRefHandle fastTravelLocation; // 1B8 + InventoryInterface::Handle inspectRequestItem; // 1BC + std::uint32_t inspectRequestStack; // 1C0 + bool pipboyExamineMode; // 1C4 + bool pipboyExamineDirtyFlag; // 1C5 + bool pipboyOpening; // 1C6 + bool pipboyClosing; // 1C7 + BSTValueEventSource pipboyActive; // 1C8 + bool ignoreOpeningFlag; // 1E0 + bool autoSaveOnClose; // 1E1 + bool pipboyMenuCloseQueued; // 1E2 + bool pipboyRaising; // 1E3 + bool wasMotionBlurActive; // 1E4 + bool wasPipboyLightActive; // 1E5 }; static_assert(sizeof(PipboyManager) == 0x1F0); } diff --git a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h index 8c3eb591..e3ac25a6 100644 --- a/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h +++ b/CommonLibF4/include/RE/Bethesda/PlayerCharacter.h @@ -104,13 +104,13 @@ namespace RE enum class PEEK_STATE; // members - NiPoint3 coverLocation; // 00 - NiPoint3 peekLocation; // 0C - float peekTimer; // 18 - float updateTimer; // 2C - float blockedTimer; // 20 - stl::enumeration peekState; // 24 - bool gunBlocked; // 28 + NiPoint3 coverLocation; // 00 + NiPoint3 peekLocation; // 0C + float peekTimer; // 18 + float updateTimer; // 2C + float blockedTimer; // 20 + REX::EnumSet peekState; // 24 + bool gunBlocked; // 28 }; static_assert(sizeof(PlayerCoverData) == 0x2C); @@ -126,9 +126,9 @@ namespace RE { public: // members - BGSQuestObjective* objective; // 00 - std::uint32_t instanceID; // 08 - stl::enumeration enstanceState; // 0C + BGSQuestObjective* objective; // 00 + std::uint32_t instanceID; // 08 + REX::EnumSet enstanceState; // 0C }; static_assert(sizeof(BGSInstancedQuestObjective) == 0x10); @@ -216,9 +216,9 @@ namespace RE { public: // members - float timer; // 0 - ObjectRefHandle refObj; // 4 - stl::enumeration next; // 8 + float timer; // 0 + ObjectRefHandle refObj; // 4 + REX::EnumSet next; // 8 }; static_assert(sizeof(PlayerActionObject) == 0xC); @@ -385,217 +385,217 @@ namespace RE } // members - BSSpinLock actorToDisplayOnHUDLock; // 628 - BSSpinLock questTargetLock; // 630 - BSTHashMap crimeGoldMap; // 638 - BSTHashMap stolenItemValueMap; // 668 - PlayerCoverData coverData; // 698 - ObjectRefHandle commandWaitMarker; // 6C4 - BSTHashMap factionOwnerFriendsMap; // 6C8 - NiPoint3A lastKnownGoodPosition; // 700 - NiPoint3A lastKnownGoodNavmeshPosition; // 710 - NiPoint3 bulletAutoAim; // 720 - NiPoint3 cachedVelocity; // 72C - BSTArray currentMapMarkers; // 738 - BSTArray> velocityArray; // 750 - BSTArray runesCast; // 768 - BSTArray animationImageSpaceModifiers; // 78- - BSTArray animationImageSpaceInstances; // 798 - BSTArray, bool>> playerLights; // 7B0 - BSSimpleList questLog; // 7C8 - BSTArray objectives; // 7D9 - BSTHashMap questTargets; // 7F0 - BSTHashMap currentSayOnceInfosMap; // 820 - BSTHashMap currentSpeechRepeatMap; // 850 - BSSimpleList droppedRefList; // 880 - NiTMap randomDoorSpaceMap; // 890 - TESWorldSpace* cachedWorldspace; // 8B0 - NiPoint3 exteriorPosition; // 8B8 - BSTSmallArray pipboyAnimSubGraph; // 8C8 - PLAYER_TARGET_LOC queuedTargetLoc; // 8E8 - PLAYER_TARGET_LOC queuedFlightLoc; // 948 - NiPoint3A flightGridCenter; // 9B0 - BSPathingSolution* flightMountPathingSolution; // 9C0 - const TESObjectCELL* flightMountPreloadCell; // 9C8 - BSSoundHandle magicFailureSound; // 9D0 - BSTArray rumorTopicInfoList; // 9D8 - std::uint32_t testChallangeInfoID; // 9F0 - DialoguePackage* closestConversation; // 9F8 - DialoguePackage* aiConversationRunning; // A00 - std::int32_t numberofStealWarnings; // A08 - float stealWarningTimer; // A0C - std::int32_t numberofPickpocketWarnings; // A10 - float pickPocketWarningTimer; // A14 - AITimeStamp warnToLeaveTimeStamp; // A18 - AITimeStamp usingTeleportDoorTimeStamp; // A1C - NiPointer ironsightsDOFInstance; // A20 - TESFaction* currentPrisonFaction; // A28 - std::uint32_t jailSentence; // A30 - NiPointer autoAimDebugSphere; // A38 - BGSNote* currHolotape; // A40 - BSSoundHandle soundHand; // A48 - std::int32_t vampireFeedDetection; // A50 - std::uint32_t mapMarkerIterator; // A54 - ObjectRefHandle forceActivateRef; // A58 - ObjectRefHandle loopingActivateRef; // A5C - std::uint32_t dialogueCameraLastSceneID; // A60 - PlayerActionObject playerActionObjects[15]; // A64 - stl::enumeration mostRecentAction; // B18 - ActorHandle actorDoingPlayerCommand; // B1C - BSTValueEventSource playerCurrentCommandType; // B20 - BSTArray> grabSprings; // B38 - NiPoint3 grabUserRotation; // B50 - ObjectRefHandle grabbedObject; // B5C - float grabObjectWeight; // B60 - float grabDistance; // B64 - std::uint32_t secondsToSleepPerUpdate; // B68 - std::uint32_t sleepSeconds; // B6C - BSTSmartPointer firstPersonBipedAnim; // B70 - NiPointer firstPerson3D; // B78 - NiAVObject* firstPersonTorso; // B80 - NiAVObject* firstPersonEye; // B88 - float eyeHeight; // B90 - float greetTimer; // B94 - float encumberedTimer; // B98 - float powerAttackTimer; // B9C - float autoReloadTimer; // BA0 - float pivotToFaceCamera; // BA4 - std::int32_t hourstosleep; // BA8 - std::int32_t amountStolenSold; // BAC - std::uint32_t valueStolen; // BB0 - ActorHandle lastRiddenMount; // BB4 - ActorHandle lightTarget; // BB8 - float sortActorDistanceTimer; // BBC - float sitHeadingDelta; // BC0 - ObjectRefHandle playerMapMarker; // BC4 - TeleportPath* playerMarkerPath; // BC8 - std::uint32_t skillTrainingsThisLevel; // BD0 - TESClass* defaultClass; // BD8 - std::uint32_t crimeCounts[7]; // BE0 - AlchemyItem* pendingPoison; // C00 - std::time_t lastPlayingTimeUpdate; // C08 - std::time_t totalPlayingTime; // C10 - std::uint32_t characterSeed; // C18 - TESForm* lastKnownGoodLocation; // C20 - NiPointer firstPersonLight; // C28 - NiPointer thirdPersonLight; // C30 - NiPointer pipboyLight; // C38 - NiPointer niPipboyLight; // C40 - float dropAngleMod; // C48 - float lastDropAngleMod; // C4C - BSTValueEventSource autoAimActor; // C50 - ObjectRefHandle homingTarget; // C68 - float homingTargetTimer; // C6C - NiPointer targeted3D; // C70 - CombatGroup* combatGroup; // C78 - BSTArray actorsToDisplayOnTheHUD; // C80 - BSTArray lastOneHandItems; // C98 - std::uint32_t teammateCount; // CB0 - float combatTimer; // CB4 - float yieldTimer; // CB8 - float chaseTimer; // CBC - float drawSheatheSafetyTimer; // CC0 - std::uint32_t activeCombatantCount; // CC4 - BGSLocation* currentLocation; // CC8 - AITimeStamp cachedVelocityTimeStamp; // CD0 - float telekinesisDistance; // CD4 - float commandTimer; // CD8 - float dialogueCameraChangeRate; // CDC - float fireWeaponEventTimer; // CE0 - stl::enumeration animationObjectAction; // CE4 - stl::enumeration grabType; // CE8 - ActorHandle assumedIdentity; // CEC - std::int8_t murder; // CF0 - std::int8_t perkCount; // CF1 - std::int8_t byCharGenFlag; // CF2 - Crime* resistArrestCrime; // CF8 - BGSCharacterTint::Entries* tintingData; // D00 - BGSTextureSet* complexion; // D08 - TESRace* charGenRace; // D10 - EffectSetting* currentAlchemyEffect; // D18 - ItemChange* currentTemperingInventoryItem; // D20 - TESObjectREFR* commandTarget; // D28 - TESObjectREFR* walkThroughDoor; // D30 - stl::enumeration currentCommand; // D38 - stl::enumeration playerDialogueInput; // D3C - ActorValueInfo* stimpakTarget; // D40 - float vatsCriticalCharge; // D48 - std::uint32_t vatsCriticalCount; // D4C - std::uint32_t maxVATSCriticalCount; // D50 - float timeBlendingOutFirstPersonOffset; // D54 - ActorHandle lastMagnetismActor; // D58 - NiPoint3 magnetismActorPos; // D5C - ObjectRefHandle workstationBeingLeft; // D68 - ActorHandle actorLeavingWorkstation; // D6C - BGSScene* allowDialogueCameraScene; // D70 - ActorHandle helloActor; // D78 - TESObjectREFR* weaponAmmoRef; // D80 - std::int32_t equippingAmmoCount; // D88 - float dialogueCameraResumeTimer; // D8C - ObjectRefHandle lastUsedPowerArmor; // D90 - TeleportPath* lastUsedPowerArmorMarkerPath; // D98 - TESObjectWEAP* lastUsedThrownWeapon; // DA0 - BSSoundHandle powerArmorInteriorSoundHandle; // DA8 - BSTArray> lockedTerminals; // DB0 - BSTArray> boneMapping1stTo3rd; // DC8 - BSTOptional syncedXPChange; // DE0 - std::int32_t queuedSwitch: 1; // DF4:00 - std::uint32_t charGenHUDMode; // DF8 - bool insideMemoryHUDMode: 1; // DFC:0 - bool xpSyncedWithHUDNotification: 1; // DFC:1 - bool travelUseDoor: 1; // DFC:2 - bool transporting: 1; // DFC:3 - bool overAutoAimTarget: 1; // DFC:4 - bool showQuestItemsInInventory: 1; // DFC:5 - bool hostileDetection: 1; // DFC:6 - bool escaping: 1; // DFC:7 - bool forceQuestTargetRepath: 1; // DFD:0 - bool speaking: 1; // DFD:1 - bool isSleeping: 1; // DFD:2 - bool actorinSneakRange: 1; // DFD:3 - bool greetingPlayer: 1; // DFD:4 - bool beenAttacked: 1; // DFD:5 - bool allowEGMCacheClear: 1; // DFD:6 - bool aiControlledToPos: 1; // DFD:7 - bool aiControlledFromPos: 1; // DFE:0 - bool aiControlledPackage: 1; // DFE:1 - bool returnToLastKnownGoodPosition: 1; // DFE:2 - bool beingChased: 1; // DFE:3 - bool is3rdPersonModelShown: 1; // DFE:4 - bool hideFirstPersonGeometry: 1; // DFE:5 - bool insufficientChargeMessageShownL: 1; // DFE:6 - bool insufficientChargeMessageShownR: 1; // DFE:7 - bool target3DDistant: 1; // DFF:0 - bool playerInCombat: 1; // DFF:1 - bool attemptedYieldInCurrentCombat: 1; // DFF:2 - bool currentAlchemyIsPoison: 1; // DFF:3 - bool positioning: 1; // DFF:4 - bool crimeReporting: 1; // DFF:5 - bool healthTutorialShown: 1; // DFF:6 - bool magickaTutorialShown: 1; // DFF:7 - bool staminaTutorialShown: 1; // E00:0 - bool goToJailQueued: 1; // E00:1 - bool doorAutosaveQueued: 1; // E00:2 - bool sprintToggled: 1; // E00:3 - bool useHighSpeedLoading: 1; // E00:4 - bool sceneActionActive: 1; // E00:5 - bool sayingHello: 1; // E00:6 - bool disabledRadio: 1; // E00:7 - bool updateAutoAimActor: 1; // E01:0 - bool autoReload: 1; // E01:1 - bool usingScopeWithOverlay: 1; // E01:2 - bool steadyingWeapon: 1; // E01:3 - bool speechChallengeReward: 1; // E01:4 - bool blendOutFirstPersonOffset: 1; // E01:5 - bool dialogueCameraConsiderResume: 1; // E01:6 - bool shouldFollowerSupressIdleChatter: 1; // E01:7 - bool idleChatter: 1; // E02:0 - bool switchingPerspectives: 1; // E02:1 - bool onElevator: 1; // E02:2 - bool sayCommandResponse: 1; // E02:3 - bool inLooksMenu: 1; // E02:4 - bool playingTimeFrozen: 1; // E02:5 - bool everModded: 1; // E02:6 + BSSpinLock actorToDisplayOnHUDLock; // 628 + BSSpinLock questTargetLock; // 630 + BSTHashMap crimeGoldMap; // 638 + BSTHashMap stolenItemValueMap; // 668 + PlayerCoverData coverData; // 698 + ObjectRefHandle commandWaitMarker; // 6C4 + BSTHashMap factionOwnerFriendsMap; // 6C8 + NiPoint3A lastKnownGoodPosition; // 700 + NiPoint3A lastKnownGoodNavmeshPosition; // 710 + NiPoint3 bulletAutoAim; // 720 + NiPoint3 cachedVelocity; // 72C + BSTArray currentMapMarkers; // 738 + BSTArray> velocityArray; // 750 + BSTArray runesCast; // 768 + BSTArray animationImageSpaceModifiers; // 78- + BSTArray animationImageSpaceInstances; // 798 + BSTArray, bool>> playerLights; // 7B0 + BSSimpleList questLog; // 7C8 + BSTArray objectives; // 7D9 + BSTHashMap questTargets; // 7F0 + BSTHashMap currentSayOnceInfosMap; // 820 + BSTHashMap currentSpeechRepeatMap; // 850 + BSSimpleList droppedRefList; // 880 + NiTMap randomDoorSpaceMap; // 890 + TESWorldSpace* cachedWorldspace; // 8B0 + NiPoint3 exteriorPosition; // 8B8 + BSTSmallArray pipboyAnimSubGraph; // 8C8 + PLAYER_TARGET_LOC queuedTargetLoc; // 8E8 + PLAYER_TARGET_LOC queuedFlightLoc; // 948 + NiPoint3A flightGridCenter; // 9B0 + BSPathingSolution* flightMountPathingSolution; // 9C0 + const TESObjectCELL* flightMountPreloadCell; // 9C8 + BSSoundHandle magicFailureSound; // 9D0 + BSTArray rumorTopicInfoList; // 9D8 + std::uint32_t testChallangeInfoID; // 9F0 + DialoguePackage* closestConversation; // 9F8 + DialoguePackage* aiConversationRunning; // A00 + std::int32_t numberofStealWarnings; // A08 + float stealWarningTimer; // A0C + std::int32_t numberofPickpocketWarnings; // A10 + float pickPocketWarningTimer; // A14 + AITimeStamp warnToLeaveTimeStamp; // A18 + AITimeStamp usingTeleportDoorTimeStamp; // A1C + NiPointer ironsightsDOFInstance; // A20 + TESFaction* currentPrisonFaction; // A28 + std::uint32_t jailSentence; // A30 + NiPointer autoAimDebugSphere; // A38 + BGSNote* currHolotape; // A40 + BSSoundHandle soundHand; // A48 + std::int32_t vampireFeedDetection; // A50 + std::uint32_t mapMarkerIterator; // A54 + ObjectRefHandle forceActivateRef; // A58 + ObjectRefHandle loopingActivateRef; // A5C + std::uint32_t dialogueCameraLastSceneID; // A60 + PlayerActionObject playerActionObjects[15]; // A64 + REX::EnumSet mostRecentAction; // B18 + ActorHandle actorDoingPlayerCommand; // B1C + BSTValueEventSource playerCurrentCommandType; // B20 + BSTArray> grabSprings; // B38 + NiPoint3 grabUserRotation; // B50 + ObjectRefHandle grabbedObject; // B5C + float grabObjectWeight; // B60 + float grabDistance; // B64 + std::uint32_t secondsToSleepPerUpdate; // B68 + std::uint32_t sleepSeconds; // B6C + BSTSmartPointer firstPersonBipedAnim; // B70 + NiPointer firstPerson3D; // B78 + NiAVObject* firstPersonTorso; // B80 + NiAVObject* firstPersonEye; // B88 + float eyeHeight; // B90 + float greetTimer; // B94 + float encumberedTimer; // B98 + float powerAttackTimer; // B9C + float autoReloadTimer; // BA0 + float pivotToFaceCamera; // BA4 + std::int32_t hourstosleep; // BA8 + std::int32_t amountStolenSold; // BAC + std::uint32_t valueStolen; // BB0 + ActorHandle lastRiddenMount; // BB4 + ActorHandle lightTarget; // BB8 + float sortActorDistanceTimer; // BBC + float sitHeadingDelta; // BC0 + ObjectRefHandle playerMapMarker; // BC4 + TeleportPath* playerMarkerPath; // BC8 + std::uint32_t skillTrainingsThisLevel; // BD0 + TESClass* defaultClass; // BD8 + std::uint32_t crimeCounts[7]; // BE0 + AlchemyItem* pendingPoison; // C00 + std::time_t lastPlayingTimeUpdate; // C08 + std::time_t totalPlayingTime; // C10 + std::uint32_t characterSeed; // C18 + TESForm* lastKnownGoodLocation; // C20 + NiPointer firstPersonLight; // C28 + NiPointer thirdPersonLight; // C30 + NiPointer pipboyLight; // C38 + NiPointer niPipboyLight; // C40 + float dropAngleMod; // C48 + float lastDropAngleMod; // C4C + BSTValueEventSource autoAimActor; // C50 + ObjectRefHandle homingTarget; // C68 + float homingTargetTimer; // C6C + NiPointer targeted3D; // C70 + CombatGroup* combatGroup; // C78 + BSTArray actorsToDisplayOnTheHUD; // C80 + BSTArray lastOneHandItems; // C98 + std::uint32_t teammateCount; // CB0 + float combatTimer; // CB4 + float yieldTimer; // CB8 + float chaseTimer; // CBC + float drawSheatheSafetyTimer; // CC0 + std::uint32_t activeCombatantCount; // CC4 + BGSLocation* currentLocation; // CC8 + AITimeStamp cachedVelocityTimeStamp; // CD0 + float telekinesisDistance; // CD4 + float commandTimer; // CD8 + float dialogueCameraChangeRate; // CDC + float fireWeaponEventTimer; // CE0 + REX::EnumSet animationObjectAction; // CE4 + REX::EnumSet grabType; // CE8 + ActorHandle assumedIdentity; // CEC + std::int8_t murder; // CF0 + std::int8_t perkCount; // CF1 + std::int8_t byCharGenFlag; // CF2 + Crime* resistArrestCrime; // CF8 + BGSCharacterTint::Entries* tintingData; // D00 + BGSTextureSet* complexion; // D08 + TESRace* charGenRace; // D10 + EffectSetting* currentAlchemyEffect; // D18 + ItemChange* currentTemperingInventoryItem; // D20 + TESObjectREFR* commandTarget; // D28 + TESObjectREFR* walkThroughDoor; // D30 + REX::EnumSet currentCommand; // D38 + REX::EnumSet playerDialogueInput; // D3C + ActorValueInfo* stimpakTarget; // D40 + float vatsCriticalCharge; // D48 + std::uint32_t vatsCriticalCount; // D4C + std::uint32_t maxVATSCriticalCount; // D50 + float timeBlendingOutFirstPersonOffset; // D54 + ActorHandle lastMagnetismActor; // D58 + NiPoint3 magnetismActorPos; // D5C + ObjectRefHandle workstationBeingLeft; // D68 + ActorHandle actorLeavingWorkstation; // D6C + BGSScene* allowDialogueCameraScene; // D70 + ActorHandle helloActor; // D78 + TESObjectREFR* weaponAmmoRef; // D80 + std::int32_t equippingAmmoCount; // D88 + float dialogueCameraResumeTimer; // D8C + ObjectRefHandle lastUsedPowerArmor; // D90 + TeleportPath* lastUsedPowerArmorMarkerPath; // D98 + TESObjectWEAP* lastUsedThrownWeapon; // DA0 + BSSoundHandle powerArmorInteriorSoundHandle; // DA8 + BSTArray> lockedTerminals; // DB0 + BSTArray> boneMapping1stTo3rd; // DC8 + BSTOptional syncedXPChange; // DE0 + std::int32_t queuedSwitch: 1; // DF4:00 + std::uint32_t charGenHUDMode; // DF8 + bool insideMemoryHUDMode: 1; // DFC:0 + bool xpSyncedWithHUDNotification: 1; // DFC:1 + bool travelUseDoor: 1; // DFC:2 + bool transporting: 1; // DFC:3 + bool overAutoAimTarget: 1; // DFC:4 + bool showQuestItemsInInventory: 1; // DFC:5 + bool hostileDetection: 1; // DFC:6 + bool escaping: 1; // DFC:7 + bool forceQuestTargetRepath: 1; // DFD:0 + bool speaking: 1; // DFD:1 + bool isSleeping: 1; // DFD:2 + bool actorinSneakRange: 1; // DFD:3 + bool greetingPlayer: 1; // DFD:4 + bool beenAttacked: 1; // DFD:5 + bool allowEGMCacheClear: 1; // DFD:6 + bool aiControlledToPos: 1; // DFD:7 + bool aiControlledFromPos: 1; // DFE:0 + bool aiControlledPackage: 1; // DFE:1 + bool returnToLastKnownGoodPosition: 1; // DFE:2 + bool beingChased: 1; // DFE:3 + bool is3rdPersonModelShown: 1; // DFE:4 + bool hideFirstPersonGeometry: 1; // DFE:5 + bool insufficientChargeMessageShownL: 1; // DFE:6 + bool insufficientChargeMessageShownR: 1; // DFE:7 + bool target3DDistant: 1; // DFF:0 + bool playerInCombat: 1; // DFF:1 + bool attemptedYieldInCurrentCombat: 1; // DFF:2 + bool currentAlchemyIsPoison: 1; // DFF:3 + bool positioning: 1; // DFF:4 + bool crimeReporting: 1; // DFF:5 + bool healthTutorialShown: 1; // DFF:6 + bool magickaTutorialShown: 1; // DFF:7 + bool staminaTutorialShown: 1; // E00:0 + bool goToJailQueued: 1; // E00:1 + bool doorAutosaveQueued: 1; // E00:2 + bool sprintToggled: 1; // E00:3 + bool useHighSpeedLoading: 1; // E00:4 + bool sceneActionActive: 1; // E00:5 + bool sayingHello: 1; // E00:6 + bool disabledRadio: 1; // E00:7 + bool updateAutoAimActor: 1; // E01:0 + bool autoReload: 1; // E01:1 + bool usingScopeWithOverlay: 1; // E01:2 + bool steadyingWeapon: 1; // E01:3 + bool speechChallengeReward: 1; // E01:4 + bool blendOutFirstPersonOffset: 1; // E01:5 + bool dialogueCameraConsiderResume: 1; // E01:6 + bool shouldFollowerSupressIdleChatter: 1; // E01:7 + bool idleChatter: 1; // E02:0 + bool switchingPerspectives: 1; // E02:1 + bool onElevator: 1; // E02:2 + bool sayCommandResponse: 1; // E02:3 + bool inLooksMenu: 1; // E02:4 + bool playingTimeFrozen: 1; // E02:5 + bool everModded: 1; // E02:6 }; static_assert(sizeof(PlayerCharacter) == 0xE10); } diff --git a/CommonLibF4/include/RE/Bethesda/PlayerControls.h b/CommonLibF4/include/RE/Bethesda/PlayerControls.h index 768dc887..7b03d4de 100644 --- a/CommonLibF4/include/RE/Bethesda/PlayerControls.h +++ b/CommonLibF4/include/RE/Bethesda/PlayerControls.h @@ -61,11 +61,11 @@ namespace RE virtual ~ActionInput(); // 00 // members - NiPointer ref; // 08 - NiPointer targetRef; // 10 - BGSAction* action; // 18 - stl::enumeration priority; // 20 - Data ActionData; // 24 + NiPointer ref; // 08 + NiPointer targetRef; // 10 + BGSAction* action; // 18 + REX::EnumSet priority; // 20 + Data ActionData; // 24 }; static_assert(sizeof(ActionInput) == 0x28); diff --git a/CommonLibF4/include/RE/Bethesda/Projectiles.h b/CommonLibF4/include/RE/Bethesda/Projectiles.h index 012e8881..fe3c5d3e 100644 --- a/CommonLibF4/include/RE/Bethesda/Projectiles.h +++ b/CommonLibF4/include/RE/Bethesda/Projectiles.h @@ -60,24 +60,24 @@ namespace RE { public: // members - NiPoint3 location; // 00 - NiPoint3 normal; // 0C - bhkCollisionQueryResultHandle impactDecalQuery; // 18 - ObjectRefHandle collidee; // 20 - NiPointer colObj; // 28 - BGSMaterialType* materialType; // 30 - stl::enumeration damageLimb; // 38 - stl::enumeration collisionLayer; // 3C - NiPointer closestBone; // 40 - stl::enumeration resultOverride; // 48 - float decalSize; // 4C - std::uint32_t collisionShapeKey; // 50 - std::int16_t targetWorldObjectCount; // 54 - std::int16_t targetWorldObjectIndex; // 56 - bool processed; // 58 - bool spellCast; // 59 - bool effectSpawned; // 5A - bool backface; // 5B + NiPoint3 location; // 00 + NiPoint3 normal; // 0C + bhkCollisionQueryResultHandle impactDecalQuery; // 18 + ObjectRefHandle collidee; // 20 + NiPointer colObj; // 28 + BGSMaterialType* materialType; // 30 + REX::EnumSet damageLimb; // 38 + REX::EnumSet collisionLayer; // 3C + NiPointer closestBone; // 40 + REX::EnumSet resultOverride; // 48 + float decalSize; // 4C + std::uint32_t collisionShapeKey; // 50 + std::int16_t targetWorldObjectCount; // 54 + std::int16_t targetWorldObjectIndex; // 56 + bool processed; // 58 + bool spellCast; // 59 + bool effectSpawned; // 5A + bool backface; // 5B }; static_assert(sizeof(ImpactData) == 0x60); @@ -120,46 +120,46 @@ namespace RE virtual bool ShouldUseDesiredTarget() { return false; } // E9 // members - BSTArray impacts; // 110 - NiTransform followOffset; // 130 - NiPointer collisionObject; // 170 - NiPointer droppedRefr; // 178 - NiPoint3 movementDirection; // 180 - NiPoint3 velocity; // 18C - NiPointer light; // 198 - NiPointer actorCause; // 1A0 - ObjectRefHandle shooter; // 1A8 - ObjectRefHandle desiredTarget; // 1AC - BSSoundHandle sndHandle; // 1B0 - BSSoundHandle sndCountdown; // 1B8 - BGSExplosion* explosion; // 1C0 - MagicItem* spell; // 1C8 - stl::enumeration castingSource; // 1D0 - EffectSetting* avEffect; // 1D8 - NiPointer projectileDBFiles; // 1E0 - void* muzzleFlashDBHandle; // 1E8 - TODO - NiPointer muzzleFlashArt; // 1F0 - BSMagicShaderParticles* particles; // 1F8 - stl::enumeration targetLimb; // 200 - NiPointer targetLimbObj; // 208 - NiAVObject* clonePoolKey; // 210 - float power; // 218 - float speedMult; // 21C - float range; // 220 - float age; // 224 - float damage; // 228 - float alpha; // 22C - float explosionTimer; // 230 - float blinkTimer; // 234 - BGSObjectInstanceT weaponSource; // 238 - TESAmmo* ammoSource; // 248 - BGSEquipIndex equipIndex; // 250 - float distanceMoved; // 254 - float movementDelta; // 258 - float scale; // 25C - std::uint64_t flags; // 260 - bool artRequested; // 268 - bool animationsLoaded; // 269 + BSTArray impacts; // 110 + NiTransform followOffset; // 130 + NiPointer collisionObject; // 170 + NiPointer droppedRefr; // 178 + NiPoint3 movementDirection; // 180 + NiPoint3 velocity; // 18C + NiPointer light; // 198 + NiPointer actorCause; // 1A0 + ObjectRefHandle shooter; // 1A8 + ObjectRefHandle desiredTarget; // 1AC + BSSoundHandle sndHandle; // 1B0 + BSSoundHandle sndCountdown; // 1B8 + BGSExplosion* explosion; // 1C0 + MagicItem* spell; // 1C8 + REX::EnumSet castingSource; // 1D0 + EffectSetting* avEffect; // 1D8 + NiPointer projectileDBFiles; // 1E0 + void* muzzleFlashDBHandle; // 1E8 - TODO + NiPointer muzzleFlashArt; // 1F0 + BSMagicShaderParticles* particles; // 1F8 + REX::EnumSet targetLimb; // 200 + NiPointer targetLimbObj; // 208 + NiAVObject* clonePoolKey; // 210 + float power; // 218 + float speedMult; // 21C + float range; // 220 + float age; // 224 + float damage; // 228 + float alpha; // 22C + float explosionTimer; // 230 + float blinkTimer; // 234 + BGSObjectInstanceT weaponSource; // 238 + TESAmmo* ammoSource; // 248 + BGSEquipIndex equipIndex; // 250 + float distanceMoved; // 254 + float movementDelta; // 258 + float scale; // 25C + std::uint64_t flags; // 260 + bool artRequested; // 268 + bool animationsLoaded; // 269 }; static_assert(sizeof(Projectile) == 0x270); @@ -175,12 +175,12 @@ namespace RE virtual bool ShouldReorient() const; // EA // members - NiMatrix3 dismemberedLimbRotation; // 270 - NiPoint3 dismemberedLimbOffset; // 2A0 - NiPointer modelCollision; // 2B0 - stl::enumeration impactResult; // 2B8 - bool waitingToInitialize3D; // 2BC - bool deferProcessImpale; // 2BD + NiMatrix3 dismemberedLimbRotation; // 270 + NiPoint3 dismemberedLimbOffset; // 2A0 + NiPointer modelCollision; // 2B0 + REX::EnumSet impactResult; // 2B8 + bool waitingToInitialize3D; // 2BC + bool deferProcessImpale; // 2BD }; static_assert(sizeof(MissileProjectile) == 0x2C0); @@ -215,38 +215,38 @@ namespace RE { public: // members - NiPoint3 origin; // 00 - NiPoint3 contactNormal; // 0C - BGSProjectile* projectileBase; // 18 - TESObjectREFR* shooter; // 20 - CombatController* shooterCombatController; // 28 - BGSObjectInstanceT fromWeapon; // 30 - TESAmmo* fromAmmo; // 40 - BGSEquipIndex equipIndex; // 48 - float zAngle; // 4C - float xAngle; // 50 - float yAngle; // 54 - TESObjectREFR* homingTarget; // 58 - TESObjectCELL* parentCell; // 60 - MagicItem* spell; // 68 - stl::enumeration castingSource; // 70 - AlchemyItem* poison; // 78 - std::int32_t area; // 80 - float power; // 84 - float scale; // 88 - float coneOfFireRadiusMult; // 8C - stl::enumeration targetLimb; // 90 - bool alwaysHit; // 94 - bool noDamageOutsideCombat; // 95 - bool autoAim; // 96 - bool useOrigin; // 97 - bool deferInitialization; // 98 - bool tracer; // 99 - bool forceConeOfFire; // 9A - bool intentionalMiss; // 9B - bool allow3D; // 9C - bool penetrates; // 9D - bool ignoreNearCollisions; // 9E + NiPoint3 origin; // 00 + NiPoint3 contactNormal; // 0C + BGSProjectile* projectileBase; // 18 + TESObjectREFR* shooter; // 20 + CombatController* shooterCombatController; // 28 + BGSObjectInstanceT fromWeapon; // 30 + TESAmmo* fromAmmo; // 40 + BGSEquipIndex equipIndex; // 48 + float zAngle; // 4C + float xAngle; // 50 + float yAngle; // 54 + TESObjectREFR* homingTarget; // 58 + TESObjectCELL* parentCell; // 60 + MagicItem* spell; // 68 + REX::EnumSet castingSource; // 70 + AlchemyItem* poison; // 78 + std::int32_t area; // 80 + float power; // 84 + float scale; // 88 + float coneOfFireRadiusMult; // 8C + REX::EnumSet targetLimb; // 90 + bool alwaysHit; // 94 + bool noDamageOutsideCombat; // 95 + bool autoAim; // 96 + bool useOrigin; // 97 + bool deferInitialization; // 98 + bool tracer; // 99 + bool forceConeOfFire; // 9A + bool intentionalMiss; // 9B + bool allow3D; // 9C + bool penetrates; // 9D + bool ignoreNearCollisions; // 9E }; static_assert(sizeof(ProjectileLaunchData) == 0xA0); diff --git a/CommonLibF4/include/RE/Bethesda/Script.h b/CommonLibF4/include/RE/Bethesda/Script.h index f86a37ee..ae059509 100644 --- a/CommonLibF4/include/RE/Bethesda/Script.h +++ b/CommonLibF4/include/RE/Bethesda/Script.h @@ -116,9 +116,9 @@ namespace RE { public: // members - const char* paramName{ "" }; // 00 - stl::enumeration paramType; // 08 - bool optional{ false }; // 0C + const char* paramName{ "" }; // 00 + REX::EnumSet paramType; // 08 + bool optional{ false }; // 0C }; static_assert(sizeof(SCRIPT_PARAMETER) == 0x10); @@ -167,15 +167,15 @@ namespace RE { public: // members - std::uint32_t lineNumber; // 000 - char line[512]; // 004 - std::uint32_t size; // 204 - std::uint32_t offset; // 208 - char output[512]; // 20C - std::uint32_t outputSize; // 40C - SCRIPT_OUTPUT expression; // 410 - std::uint32_t refObjectIndex; // 414 - stl::enumeration scriptError; // 418 + std::uint32_t lineNumber; // 000 + char line[512]; // 004 + std::uint32_t size; // 204 + std::uint32_t offset; // 208 + char output[512]; // 20C + std::uint32_t outputSize; // 40C + SCRIPT_OUTPUT expression; // 410 + std::uint32_t refObjectIndex; // 414 + REX::EnumSet scriptError; // 418 }; static_assert(sizeof(SCRIPT_LINE) == 0x41C); @@ -216,20 +216,20 @@ namespace RE { public: // members - const char* input; // 00 - std::uint32_t inputOffset; // 08 - stl::enumeration compilerIndex; // 0C - BSStringT scriptName; // 10 - SCRIPT_ERROR lastError; // 20 - bool isPartialScript; // 24 - std::uint32_t uiLastLineNumber; // 28 - char* output; // 30 - std::uint32_t outputOffset; // 38 - SCRIPT_HEADER header; // 3C - BSSimpleList listVariables; // 50 - BSSimpleList listRefObjects; // 60 - Script* currentScript; // 70 - BSSimpleList listLines; // 78 + const char* input; // 00 + std::uint32_t inputOffset; // 08 + REX::EnumSet compilerIndex; // 0C + BSStringT scriptName; // 10 + SCRIPT_ERROR lastError; // 20 + bool isPartialScript; // 24 + std::uint32_t uiLastLineNumber; // 28 + char* output; // 30 + std::uint32_t outputOffset; // 38 + SCRIPT_HEADER header; // 3C + BSSimpleList listVariables; // 50 + BSSimpleList listRefObjects; // 60 + Script* currentScript; // 70 + BSSimpleList listLines; // 78 }; static_assert(sizeof(ScriptCompileData) == 0x88); @@ -272,7 +272,7 @@ namespace RE // members const char* functionName{ "" }; // 00 const char* shortName{ "" }; // 08 - stl::enumeration output; // 10 + REX::EnumSet output; // 10 const char* helpString{ "" }; // 18 bool referenceFunction{ false }; // 20 std::uint16_t paramCount{ 0 }; // 22 diff --git a/CommonLibF4/include/RE/Bethesda/Sky.h b/CommonLibF4/include/RE/Bethesda/Sky.h index 2f447019..6f49f38d 100644 --- a/CommonLibF4/include/RE/Bethesda/Sky.h +++ b/CommonLibF4/include/RE/Bethesda/Sky.h @@ -149,14 +149,14 @@ namespace RE float currentWeatherPct; // 360 float lastWindDirection; // 364 float lastWindDirectionRange; // 368 - stl::enumeration mode; // 36C + REX::EnumSet mode; // 36C BSSimpleList* skySoundList; // 370 float flash; // 378 std::uint64_t flashTime; // 380 std::uint32_t lastMoonPhaseUpdate; // 388 float windowReflectionTimer; // 38C float accelBeginPct; // 390 - stl::enumeration flags; // 394 + REX::EnumSet flags; // 394 ImageSpaceModifierInstanceForm* currentWeatherImageSpaceMod; // 398 ImageSpaceModifierInstanceForm* currentWeatherImageSpaceMod2; // 3A0 ImageSpaceModifierInstanceForm* lastWeatherImageSpaceMod; // 3A8 diff --git a/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h b/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h index a732de0d..2605ba88 100644 --- a/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h +++ b/CommonLibF4/include/RE/Bethesda/TESBoundAnimObjects.h @@ -242,7 +242,7 @@ namespace RE }; // members - stl::enumeration type; // 0 + REX::EnumSet type; // 0 }; static_assert(sizeof(WorkbenchData) == 0x1); diff --git a/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h b/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h index 42246cd2..95967721 100644 --- a/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h +++ b/CommonLibF4/include/RE/Bethesda/TESBoundObjects.h @@ -186,7 +186,7 @@ namespace RE float colorRemappingIndex; // 44 std::uint32_t value; // 48 std::uint32_t health; // 4C - stl::enumeration staggerRating; // 50 + REX::EnumSet staggerRating; // 50 std::uint16_t rating; // 54 std::uint16_t index; // 56 }; @@ -378,16 +378,16 @@ namespace RE { public: // members - std::int8_t density; // 00 - std::int8_t minSlopeDegrees; // 01 - std::int8_t maxSlopeDegrees; // 02 - std::uint16_t distanceFromWaterLevel; // 04 - stl::enumeration underwater; // 08 - float positionRange; // 0C - float heightRange; // 10 - float colorRange; // 14 - float wavePeriod; // 18 - std::int8_t flags; // 1C + std::int8_t density; // 00 + std::int8_t minSlopeDegrees; // 01 + std::int8_t maxSlopeDegrees; // 02 + std::uint16_t distanceFromWaterLevel; // 04 + REX::EnumSet underwater; // 08 + float positionRange; // 0C + float heightRange; // 10 + float colorRange; // 14 + float wavePeriod; // 18 + std::int8_t flags; // 1C }; static_assert(sizeof(GRASS_DATA) == 0x20); @@ -457,9 +457,9 @@ namespace RE enum class etTreeType; // members - OBJ_TREE data; // 0D8 - BaseTreeData* baseData; // 108 - stl::enumeration type; // 110 + OBJ_TREE data; // 0D8 + BaseTreeData* baseData; // 108 + REX::EnumSet type; // 110 }; static_assert(sizeof(TESObjectTREE) == 0x118); @@ -541,17 +541,17 @@ namespace RE { public: // members - BGSProjectile* overrideProjectile; // 00 - float fireSeconds; // 08 - float firingRumbleLeftMotorStrength; // 0C - float firingRumbleRightMotorStrength; // 10 - float firingRumbleDuration; // 14 - float reloadSeconds; // 18 - float boltChargeSeconds; // 1C - float sightedTransitionSeconds; // 20 - std::uint32_t rumblePeriod; // 24 - stl::enumeration rumblePattern; // 28 - std::int8_t numProjectiles; // 2C + BGSProjectile* overrideProjectile; // 00 + float fireSeconds; // 08 + float firingRumbleLeftMotorStrength; // 0C + float firingRumbleRightMotorStrength; // 10 + float firingRumbleDuration; // 14 + float reloadSeconds; // 18 + float boltChargeSeconds; // 1C + float sightedTransitionSeconds; // 20 + std::uint32_t rumblePeriod; // 24 + REX::EnumSet rumblePattern; // 28 + std::int8_t numProjectiles; // 2C }; static_assert(sizeof(RangedData) == 0x30); @@ -603,18 +603,18 @@ namespace RE float minPowerPerShot; // 0FC float colorRemappingIndex; // 100 float criticalDamageMult; // 104 - stl::enumeration staggerValue; // 108 + REX::EnumSet staggerValue; // 108 std::uint32_t value; // 10C - stl::enumeration flags; // 110 - stl::enumeration soundLevel; // 114 - stl::enumeration hitBehavior; // 118 + REX::EnumSet flags; // 110 + REX::EnumSet soundLevel; // 114 + REX::EnumSet hitBehavior; // 118 ActorValueInfo* skill; // 120 ActorValueInfo* resistance; // 128 std::uint16_t ammoCapacity; // 130 std::uint16_t attackDamage; // 132 std::uint16_t rank; // 134 std::int8_t accuracyBonus; // 136 - stl::enumeration type; // 137 + REX::EnumSet type; // 137 }; static_assert(sizeof(InstanceData) == 0x138); @@ -887,9 +887,9 @@ namespace RE } // members - BGSProjectileData data; // 0C0 - TESModel muzzleFlashModel; // 150 - stl::enumeration soundLevel; // 180 + BGSProjectileData data; // 0C0 + TESModel muzzleFlashModel; // 150 + REX::EnumSet soundLevel; // 180 }; static_assert(sizeof(BGSProjectile) == 0x188); @@ -908,19 +908,19 @@ namespace RE }; // members - std::uint32_t limit; // 00 - float radius; // 04 - float lifetime; // 08 - float imageSpaceRadius; // 0C - float targetInterval; // 10 - stl::enumeration flags; // 14 - SpellItem* spell; // 18 - TESObjectLIGH* light; // 20 - BGSImpactDataSet* impactDataSet; // 28 - BGSSoundDescriptorForm* sound; // 30 - float fullEffectRadius; // 38 - float taperWeight; // 3C - float taperCurve; // 40 + std::uint32_t limit; // 00 + float radius; // 04 + float lifetime; // 08 + float imageSpaceRadius; // 0C + float targetInterval; // 10 + REX::EnumSet flags; // 14 + SpellItem* spell; // 18 + TESObjectLIGH* light; // 20 + BGSImpactDataSet* impactDataSet; // 28 + BGSSoundDescriptorForm* sound; // 30 + float fullEffectRadius; // 38 + float taperWeight; // 3C + float taperCurve; // 40 }; static_assert(sizeof(BGSHazardData) == 0x48); @@ -1017,25 +1017,25 @@ namespace RE { public: // members - TESObjectLIGH* light; // 00 - BGSSoundDescriptorForm* sound1; // 08 - BGSSoundDescriptorForm* sound2; // 10 - BGSImpactDataSet* impactDataSet; // 18 - TESBoundObject* impactPlacedObject; // 20 - BGSProjectile* spawnProjectile; // 28 - NiPoint3 projectileVector; // 30 - float projectileSpread; // 3C - std::uint32_t projectileCount; // 40 - float force; // 44 - float damage; // 48 - float innerRadius; // 4C - float outerRadius; // 50 - float imageSpaceRadius; // 54 - float verticalOffsetMult; // 58 - std::uint32_t flags; // 5C - stl::enumeration soundLevel; // 60 - float placedObjectFadeDelay; // 64 - stl::enumeration staggerMagnitude; // 68 + TESObjectLIGH* light; // 00 + BGSSoundDescriptorForm* sound1; // 08 + BGSSoundDescriptorForm* sound2; // 10 + BGSImpactDataSet* impactDataSet; // 18 + TESBoundObject* impactPlacedObject; // 20 + BGSProjectile* spawnProjectile; // 28 + NiPoint3 projectileVector; // 30 + float projectileSpread; // 3C + std::uint32_t projectileCount; // 40 + float force; // 44 + float damage; // 48 + float innerRadius; // 4C + float outerRadius; // 50 + float imageSpaceRadius; // 54 + float verticalOffsetMult; // 58 + std::uint32_t flags; // 5C + REX::EnumSet soundLevel; // 60 + float placedObjectFadeDelay; // 64 + REX::EnumSet staggerMagnitude; // 68 }; static_assert(sizeof(BGSExplosionData) == 0x70); @@ -1136,7 +1136,7 @@ namespace RE { public: // members - stl::enumeration artType; // 0 + REX::EnumSet artType; // 0 }; static_assert(sizeof(Data) == 0x4); diff --git a/CommonLibF4/include/RE/Bethesda/TESCamera.h b/CommonLibF4/include/RE/Bethesda/TESCamera.h index 364d15ce..a8dd7945 100644 --- a/CommonLibF4/include/RE/Bethesda/TESCamera.h +++ b/CommonLibF4/include/RE/Bethesda/TESCamera.h @@ -73,8 +73,8 @@ namespace RE virtual void Revert([[maybe_unused]] BGSLoadFormBuffer* a_loadGameBuffer) { return; } // 10 // members - TESCamera* camera; // 18 - stl::enumeration id; // 20 + TESCamera* camera; // 18 + REX::EnumSet id; // 20 }; static_assert(sizeof(TESCameraState) == 0x28); diff --git a/CommonLibF4/include/RE/Bethesda/TESCondition.h b/CommonLibF4/include/RE/Bethesda/TESCondition.h index 7af87583..71472948 100644 --- a/CommonLibF4/include/RE/Bethesda/TESCondition.h +++ b/CommonLibF4/include/RE/Bethesda/TESCondition.h @@ -41,8 +41,8 @@ namespace RE { public: // members - stl::enumeration function; // 00 - void* param[2]; // 08 + REX::EnumSet function; // 00 + void* param[2]; // 08 }; static_assert(sizeof(FUNCTION_DATA) == 0x18); @@ -54,17 +54,17 @@ namespace RE { TESGlobal* global; float value; - }; // 00 - ObjectRefHandle runOnRef; // 08 - std::uint32_t dataID; // 0C - FUNCTION_DATA functionData; // 10 - std::uint8_t compareOr: 1; // 28:0 - std::uint8_t aliasParams: 1; // 28:1 - std::uint8_t valueIsGlobal: 1; // 28:2 - std::uint8_t packDataParams: 1; // 28:3 - std::uint8_t swapsSubjectAndTarget: 1; // 28:4 - ENUM_COMPARISON_CONDITION condition: 3; // 28:5 - stl::enumeration object; // 29 + }; // 00 + ObjectRefHandle runOnRef; // 08 + std::uint32_t dataID; // 0C + FUNCTION_DATA functionData; // 10 + std::uint8_t compareOr: 1; // 28:0 + std::uint8_t aliasParams: 1; // 28:1 + std::uint8_t valueIsGlobal: 1; // 28:2 + std::uint8_t packDataParams: 1; // 28:3 + std::uint8_t swapsSubjectAndTarget: 1; // 28:4 + ENUM_COMPARISON_CONDITION condition: 3; // 28:5 + REX::EnumSet object; // 29 }; static_assert(sizeof(CONDITION_ITEM_DATA) == 0x30); diff --git a/CommonLibF4/include/RE/Bethesda/TESFile.h b/CommonLibF4/include/RE/Bethesda/TESFile.h index e16a3e4f..12bdbaa6 100644 --- a/CommonLibF4/include/RE/Bethesda/TESFile.h +++ b/CommonLibF4/include/RE/Bethesda/TESFile.h @@ -169,7 +169,7 @@ namespace RE } // members - stl::enumeration lastError; // 000 + REX::EnumSet lastError; // 000 TESFile* threadSafeParent; // 008 BSTHashMap threadSafeFileMap; // 010 BSTSmartPointer pageCache; // 040 @@ -187,7 +187,7 @@ namespace RE TESObjectCELL* currCell; // 290 std::uint32_t currRefOffset; // 298 FORM currentform; // 29C - stl::enumeration currentchunkID; // 2B4 + REX::EnumSet currentchunkID; // 2B4 std::uint32_t actualChunkSize; // 2B8 std::uint32_t filesize; // 2BC std::uint32_t fileoffset; // 2C0 @@ -200,7 +200,7 @@ namespace RE bool hasGroups; // 300 BSSystemFile::Info fileInfo; // 308 FILE_HEADER fileHeaderInfo; // 328 - stl::enumeration flags; // 334 + REX::EnumSet flags; // 334 BSSimpleList masters; // 338 BSSimpleList<_ULARGE_INTEGER*> mastersData; // 348 std::uint32_t masterCount; // 358 diff --git a/CommonLibF4/include/RE/Bethesda/TESForms.h b/CommonLibF4/include/RE/Bethesda/TESForms.h index e63d7f66..60dbbfb4 100644 --- a/CommonLibF4/include/RE/Bethesda/TESForms.h +++ b/CommonLibF4/include/RE/Bethesda/TESForms.h @@ -906,11 +906,11 @@ namespace RE [[nodiscard]] const T* As() const noexcept; // members - TESFileContainer sourceFiles; // 08 - std::uint32_t formFlags; // 10 - std::uint32_t formID; // 14 - std::uint16_t inGameFormFlags; // 18 - stl::enumeration formType; // 1A + TESFileContainer sourceFiles; // 08 + std::uint32_t formFlags; // 10 + std::uint32_t formID; // 14 + std::uint16_t inGameFormFlags; // 18 + REX::EnumSet formType; // 1A }; static_assert(sizeof(TESForm) == 0x20); @@ -1143,44 +1143,44 @@ namespace RE }; // members - stl::enumeration flags; // 000 - float baseCost; // 004 - TESForm* associatedForm; // 008 - ActorValueInfo* associatedSkill; // 010 - ActorValueInfo* resistVariable; // 018 - std::int16_t numCounterEffects; // 020 - TESObjectLIGH* light; // 028 - float taperWeight; // 030 - TESEffectShader* effectShader; // 038 - TESEffectShader* enchantEffect; // 040 - std::int32_t minimumSkill; // 048 - std::int32_t spellmakingArea; // 04C - float spellmakingChargeTime; // 050 - float taperCurve; // 054 - float taperDuration; // 058 - float secondaryAVWeight; // 05C - stl::enumeration archetype; // 060 - ActorValueInfo* primaryAV; // 068 - BGSProjectile* projectileBase; // 070 - BGSExplosion* explosion; // 078 - stl::enumeration castingType; // 080 - stl::enumeration delivery; // 084 - ActorValueInfo* secondaryAV; // 088 - BGSArtObject* castingArt; // 090 - BGSArtObject* hitEffectArt; // 098 - BGSImpactDataSet* impactDataSet; // 0A0 - float skillUsageMult; // 0A8 - BGSDualCastData* dualCastData; // 0B0 - float dualCastScale; // 0B8 - BGSArtObject* enchantEffectArt; // 0C0 - BGSReferenceEffect* hitVisuals; // 0C8 - BGSReferenceEffect* enchantVisuals; // 0D0 - SpellItem* equipAbility; // 0D8 - TESImageSpaceModifier* imageSpaceMod; // 0E0 - BGSPerk* perk; // 0E8 - stl::enumeration castingSoundLevel; // 0F0 - float aiScore; // 0F4 - float aiDelayTime; // 0F8 + REX::EnumSet flags; // 000 + float baseCost; // 004 + TESForm* associatedForm; // 008 + ActorValueInfo* associatedSkill; // 010 + ActorValueInfo* resistVariable; // 018 + std::int16_t numCounterEffects; // 020 + TESObjectLIGH* light; // 028 + float taperWeight; // 030 + TESEffectShader* effectShader; // 038 + TESEffectShader* enchantEffect; // 040 + std::int32_t minimumSkill; // 048 + std::int32_t spellmakingArea; // 04C + float spellmakingChargeTime; // 050 + float taperCurve; // 054 + float taperDuration; // 058 + float secondaryAVWeight; // 05C + REX::EnumSet archetype; // 060 + ActorValueInfo* primaryAV; // 068 + BGSProjectile* projectileBase; // 070 + BGSExplosion* explosion; // 078 + REX::EnumSet castingType; // 080 + REX::EnumSet delivery; // 084 + ActorValueInfo* secondaryAV; // 088 + BGSArtObject* castingArt; // 090 + BGSArtObject* hitEffectArt; // 098 + BGSImpactDataSet* impactDataSet; // 0A0 + float skillUsageMult; // 0A8 + BGSDualCastData* dualCastData; // 0B0 + float dualCastScale; // 0B8 + BGSArtObject* enchantEffectArt; // 0C0 + BGSReferenceEffect* hitVisuals; // 0C8 + BGSReferenceEffect* enchantVisuals; // 0D0 + SpellItem* equipAbility; // 0D8 + TESImageSpaceModifier* imageSpaceMod; // 0E0 + BGSPerk* perk; // 0E8 + REX::EnumSet castingSoundLevel; // 0F0 + float aiScore; // 0F4 + float aiDelayTime; // 0F8 }; static_assert(sizeof(EffectSettingData) == 0x100); @@ -1188,8 +1188,8 @@ namespace RE { public: // members - stl::enumeration id; // 00 - BGSSoundDescriptorForm* sound; // 08 + REX::EnumSet id; // 00 + BGSSoundDescriptorForm* sound; // 08 }; static_assert(sizeof(SoundPair) == 0x10); @@ -1268,8 +1268,8 @@ namespace RE { public: // members - BGSSoundDescriptorForm* soundForm; // 00 - stl::enumeration type; // 08 + BGSSoundDescriptorForm* soundForm; // 00 + REX::EnumSet type; // 08 }; static_assert(sizeof(WeatherSound) == 0x10); @@ -1281,7 +1281,7 @@ namespace RE static_assert(sizeof(WeatherSoundList) == 0x10); // members - stl::enumeration context; // 020 + REX::EnumSet context; // 020 TESTexture1024 cloudTexture[32]; // 028 std::int8_t cloudLayerSpeedY[32]; // 228 std::int8_t cloudLayerSpeedX[32]; // 248 @@ -1376,9 +1376,9 @@ namespace RE { public: // members - BGSArtObject* artObject; // 00 - TESEffectShader* effectShader; // 08 - stl::enumeration flags; // 10 + BGSArtObject* artObject; // 00 + TESEffectShader* effectShader; // 08 + REX::EnumSet flags; // 10 }; static_assert(sizeof(Data) == 0x18); @@ -1558,14 +1558,14 @@ namespace RE [[nodiscard]] bool IsInterior() const noexcept { return cellFlags.all(Flag::kInterior); } // members - BSSpinLock grassCreateLock; // 30 - BSSpinLock grassTaskLock; // 38 - stl::enumeration cellFlags; // 40 - std::uint16_t cellGameFlags; // 42 - stl::enumeration cellState; // 44 - bool autoWaterLoaded; // 45 - bool cellDetached; // 46 - BSTSmartPointer extraList; // 48 + BSSpinLock grassCreateLock; // 30 + BSSpinLock grassTaskLock; // 38 + REX::EnumSet cellFlags; // 40 + std::uint16_t cellGameFlags; // 42 + REX::EnumSet cellState; // 44 + bool autoWaterLoaded; // 45 + bool cellDetached; // 46 + BSTSmartPointer extraList; // 48 union { void* cellData; @@ -1611,7 +1611,7 @@ namespace RE }; // members - stl::enumeration flags; // 0 + REX::EnumSet flags; // 0 }; static_assert(sizeof(OBJ_LAND) == 0x4); @@ -1700,8 +1700,8 @@ namespace RE }; // members - stl::enumeration flags; // 0 - std::uint16_t timeUntilReset; // 2 + REX::EnumSet flags; // 0 + std::uint16_t timeUntilReset; // 2 }; static_assert(sizeof(TOPIC_INFO_DATA) == 0x4); @@ -1876,42 +1876,42 @@ namespace RE { public: // members - stl::enumeration<_D3DBLEND, std::int32_t> textureBlendModeSource; // 00 - stl::enumeration<_D3DBLENDOP, std::int32_t> textureBlendOperation; // 04 - stl::enumeration<_D3DCMPFUNC, std::int32_t> textureZTestFunction; // 08 - std::uint32_t fillColor1; // 0C - float fillAlphaFadeInTime; // 10 - float fillAlphaFullTime; // 14 - float fillAlphaFadeOutTime; // 18 - float fillAlphaPersistentPercent; // 1C - float fillAlphaPulseAmplitude; // 20 - float fillAlphaPulseFrequency; // 24 - float fillTextureUAnimSpeed; // 28 - float fillTextureVAnimSpeed; // 2C - float edgeExponentValue; // 30 - std::uint32_t edgeColor; // 34 - float edgeAlphaFadeInTime; // 38 - float edgeAlphaFullTime; // 3C - float edgeAlphaFadeOutTime; // 40 - float edgeAlphaPersistentPercent; // 44 - float edgeAlphaPulseAmplitude; // 48 - float edgeAlphaPulseFrequency; // 4C - float fillAlphaFullPercent; // 50 - float edgeAlphaFullPercent; // 54 - stl::enumeration<_D3DBLEND, std::int32_t> textureBlendModeDest; // 58 - float alphaTestStartTime; // 5C - float alphaTestEndTime; // 60 - float alphaTestStartValue; // 64 - float alphaTestEndValue; // 68 - BGSSoundDescriptorForm* ambientSound; // 70 - std::uint32_t fillColor2; // 78 - std::uint32_t fillColor3; // 7C - float fillColorScaleA[3]; // 80 - float fillColorTimeA[3]; // 8C - std::uint32_t flags; // 98 - float fillTextureUScale; // 9C - float fillTextureVScale; // A0 - std::int8_t boneDepth; // A4 + REX::EnumSet<_D3DBLEND, std::int32_t> textureBlendModeSource; // 00 + REX::EnumSet<_D3DBLENDOP, std::int32_t> textureBlendOperation; // 04 + REX::EnumSet<_D3DCMPFUNC, std::int32_t> textureZTestFunction; // 08 + std::uint32_t fillColor1; // 0C + float fillAlphaFadeInTime; // 10 + float fillAlphaFullTime; // 14 + float fillAlphaFadeOutTime; // 18 + float fillAlphaPersistentPercent; // 1C + float fillAlphaPulseAmplitude; // 20 + float fillAlphaPulseFrequency; // 24 + float fillTextureUAnimSpeed; // 28 + float fillTextureVAnimSpeed; // 2C + float edgeExponentValue; // 30 + std::uint32_t edgeColor; // 34 + float edgeAlphaFadeInTime; // 38 + float edgeAlphaFullTime; // 3C + float edgeAlphaFadeOutTime; // 40 + float edgeAlphaPersistentPercent; // 44 + float edgeAlphaPulseAmplitude; // 48 + float edgeAlphaPulseFrequency; // 4C + float fillAlphaFullPercent; // 50 + float edgeAlphaFullPercent; // 54 + REX::EnumSet<_D3DBLEND, std::int32_t> textureBlendModeDest; // 58 + float alphaTestStartTime; // 5C + float alphaTestEndTime; // 60 + float alphaTestStartValue; // 64 + float alphaTestEndValue; // 68 + BGSSoundDescriptorForm* ambientSound; // 70 + std::uint32_t fillColor2; // 78 + std::uint32_t fillColor3; // 7C + float fillColorScaleA[3]; // 80 + float fillColorTimeA[3]; // 8C + std::uint32_t flags; // 98 + float fillTextureUScale; // 9C + float fillTextureVScale; // A0 + std::int8_t boneDepth; // A4 }; static_assert(sizeof(EffectShaderData) == 0xA8); @@ -2245,22 +2245,22 @@ namespace RE { public: // members - stl::enumeration cameraAction; // 00 - stl::enumeration location; // 04 - stl::enumeration target; // 08 - std::uint32_t flags; // 0C - float playerTimeMult; // 10 - float targetTimeMult; // 14 - float globalTimeMult; // 18 - float maxTime; // 1C - float minTime; // 20 - float targetPercentBetweenActors; // 24 - float nearTargetDistance; // 28 - float locationSpring; // 2C - float targetSpring; // 30 - float rotationOffsetX; // 34 - float rotationOffsetY; // 38 - float rotationOffsetZ; // 3C + REX::EnumSet cameraAction; // 00 + REX::EnumSet location; // 04 + REX::EnumSet target; // 08 + std::uint32_t flags; // 0C + float playerTimeMult; // 10 + float targetTimeMult; // 14 + float globalTimeMult; // 18 + float maxTime; // 1C + float minTime; // 20 + float targetPercentBetweenActors; // 24 + float nearTargetDistance; // 28 + float locationSpring; // 2C + float targetSpring; // 30 + float rotationOffsetX; // 34 + float rotationOffsetY; // 38 + float rotationOffsetZ; // 3C }; static_assert(sizeof(CAMERA_SHOT_DATA) == 0x40); @@ -2378,13 +2378,13 @@ namespace RE { public: // members - float effectDuration; // 00 - stl::enumeration orient; // 04 - float angleThreshold; // 08 - float placementRadius; // 0C - stl::enumeration soundLevel; // 10 - std::int8_t flags; // 14 - std::int8_t resultOverride; // 15 + float effectDuration; // 00 + REX::EnumSet orient; // 04 + float angleThreshold; // 08 + float placementRadius; // 0C + REX::EnumSet soundLevel; // 10 + std::int8_t flags; // 14 + std::int8_t resultOverride; // 15 }; static_assert(sizeof(IMPACT_DATA_DATA) == 0x18); @@ -2438,12 +2438,12 @@ namespace RE }; // members - TESForm* zoneOwner; // 00 - BGSLocation* location; // 08 - std::int8_t ownerRank; // 10 - std::int8_t minLevel; // 11 - stl::enumeration flags; // 12 - std::int8_t maxLevel; // 13 + TESForm* zoneOwner; // 00 + BGSLocation* location; // 08 + std::int8_t ownerRank; // 10 + std::int8_t minLevel; // 11 + REX::EnumSet flags; // 12 + std::int8_t maxLevel; // 13 }; static_assert(sizeof(ENCOUNTER_ZONE_DATA) == 0x18); @@ -2801,10 +2801,10 @@ namespace RE static constexpr auto FORM_ID{ ENUM_FORM_ID::kDLBR }; // members - std::uint32_t flags; // 20 - TESQuest* quest; // 28 - TESTopic* startingTopic; // 30 - stl::enumeration type; // 38 + std::uint32_t flags; // 20 + TESQuest* quest; // 28 + TESTopic* startingTopic; // 30 + REX::EnumSet type; // 38 }; static_assert(sizeof(BGSDialogueBranch) == 0x40); @@ -3057,12 +3057,12 @@ namespace RE struct SpeakerArrays; // members - DynamicAttenuationCharacteristics* attenuation; // 28 - SpeakerArrays* speakerOutputArrays; // 30 - BGSAudioEffectChain* effectChain; // 38 - std::uint32_t flags; // 40 - stl::enumeration mode; // 44 - std::uint16_t staticAttenuation; // 48 + DynamicAttenuationCharacteristics* attenuation; // 28 + SpeakerArrays* speakerOutputArrays; // 30 + BGSAudioEffectChain* effectChain; // 38 + std::uint32_t flags; // 40 + REX::EnumSet mode; // 44 + std::uint16_t staticAttenuation; // 48 }; static_assert(sizeof(BGSSoundOutput) == 0x50); @@ -3292,7 +3292,7 @@ namespace RE static_assert(sizeof(RuleSet) == 0x18); // members - stl::enumeration type; // 020 + REX::EnumSet type; // 020 RuleSet ruleSets[10]; // 028 BSTArray mergeSources; // 118 }; diff --git a/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h b/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h index eb668890..813e8eef 100644 --- a/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h +++ b/CommonLibF4/include/RE/Bethesda/TESObjectREFRs.h @@ -89,11 +89,11 @@ namespace RE { public: // members - stl::enumeration changeType; // 00 - ObjectRefHandle owner; // 04 - TESBoundObject* objAffected; // 08 - std::uint32_t count; // 10 - std::uint32_t stackID; // 14 + REX::EnumSet changeType; // 00 + ObjectRefHandle owner; // 04 + TESBoundObject* objAffected; // 08 + std::uint32_t count; // 10 + std::uint32_t stackID; // 14 }; static_assert(sizeof(Event) == 0x18); } @@ -956,9 +956,9 @@ namespace RE { public: // members - stl::enumeration limb; // 00 - ActorValueInfo* limbCondition; // 08 - float distance; // 10 + REX::EnumSet limb; // 00 + ActorValueInfo* limbCondition; // 08 + float distance; // 10 }; static_assert(sizeof(ExplodedLimb) == 0x18); diff --git a/CommonLibF4/include/RE/Bethesda/TESPackages.h b/CommonLibF4/include/RE/Bethesda/TESPackages.h index eb56157c..74fe05ee 100644 --- a/CommonLibF4/include/RE/Bethesda/TESPackages.h +++ b/CommonLibF4/include/RE/Bethesda/TESPackages.h @@ -59,7 +59,7 @@ namespace RE enum class TOPIC_MODE; // members - stl::enumeration mode; // 0 + REX::EnumSet mode; // 0 union { DIALOGUE_SUBTYPE generalTopicSubtype; @@ -72,9 +72,9 @@ namespace RE { public: // members - TESIdleForm* idle; // 00 - stl::enumeration type; // 08 - BGSTopicSubtypeUnion topicSubtypeUnion; // 0C + TESIdleForm* idle; // 00 + REX::EnumSet type; // 08 + BGSTopicSubtypeUnion topicSubtypeUnion; // 0C }; static_assert(sizeof(PackageEventAction) == 0x18); @@ -94,20 +94,20 @@ namespace RE virtual bool IsPackageOwner(Actor*) { return true; } // 4E // members - PACKAGE_DATA data; // 20 - TESPackageData* packData; // 30 - PackageLocation* packLoc; // 38 - PackageTarget* packTarg; // 40 - BGSIdleCollection* idleCollection; // 48 - PackageSchedule packSched; // 50 - TESCondition packConditions; // 60 - TESCombatStyle* combatStyle; // 68 - TESQuest* ownerQuest; // 70 - PackageEventAction onBegin; // 78 - PackageEventAction onEnd; // 90 - PackageEventAction onChange; // A8 - stl::enumeration procedureType; // C0 - std::uint32_t refCount; // C4 + PACKAGE_DATA data; // 20 + TESPackageData* packData; // 30 + PackageLocation* packLoc; // 38 + PackageTarget* packTarg; // 40 + BGSIdleCollection* idleCollection; // 48 + PackageSchedule packSched; // 50 + TESCondition packConditions; // 60 + TESCombatStyle* combatStyle; // 68 + TESQuest* ownerQuest; // 70 + PackageEventAction onBegin; // 78 + PackageEventAction onEnd; // 90 + PackageEventAction onChange; // A8 + REX::EnumSet procedureType; // C0 + std::uint32_t refCount; // C4 }; static_assert(sizeof(TESPackage) == 0xC8); @@ -174,16 +174,16 @@ namespace RE enum class THREAT_LEVEL; // members - ActorHandle source; // 00 - ActorHandle target; // 04 - stl::enumeration threatLevel; // 08 - std::time_t lastPerceivedTime; // 10 - float radius; // 18 - NiPoint3 lastKnownPosSource; // 1C - NiPoint3 lastKnownPosTarget; // 28 - bool hasSource; // 34 - bool hasTarget; // 35 - NiPointer debugGeometry; // 38 + ActorHandle source; // 00 + ActorHandle target; // 04 + REX::EnumSet threatLevel; // 08 + std::time_t lastPerceivedTime; // 10 + float radius; // 18 + NiPoint3 lastKnownPosSource; // 1C + NiPoint3 lastKnownPosTarget; // 28 + bool hasSource; // 34 + bool hasTarget; // 35 + NiPointer debugGeometry; // 38 }; static_assert(sizeof(SpectatorThreatInfo) == 0x40); diff --git a/CommonLibF4/include/RE/Bethesda/TESRace.h b/CommonLibF4/include/RE/Bethesda/TESRace.h index ccd345f6..58092152 100644 --- a/CommonLibF4/include/RE/Bethesda/TESRace.h +++ b/CommonLibF4/include/RE/Bethesda/TESRace.h @@ -29,50 +29,50 @@ namespace RE { public: // members - float height[2]; // 000 - NiPoint3 weight[2]; // 008 - std::int32_t flags; // 020 - float accelerate; // 024 - float decelerate; // 028 - stl::enumeration raceSize; // 02C - stl::enumeration headObject; // 030 - stl::enumeration hairObject; // 034 - stl::enumeration beardObject; // 038 - float injuredHealthPercent; // 03C - stl::enumeration shieldObject; // 040 - stl::enumeration bodyObject; // 044 - float aimAngleTolerance; // 048 - float flightRadius; // 04C - float angleAccelerate; // 050 - float angleTolerance; // 054 - std::uint32_t flags2; // 058 - NiPoint3 mountOffset; // 05C - NiPoint3 dismountOffset; // 068 - NiPoint3 mountCameraOffset; // 074 - stl::enumeration pipboyObject; // 080 - std::int16_t xpValue; // 084 - BGSExplosion* onCrippleExplosion; // 088 - BGSDebris* onCrippleGenericDebris; // 090 - BGSImpactDataSet* onCrippleImpactDataSet; // 098 - float onCrippleGenericDebrisScale; // 0A0 - std::int8_t onCrippleGenericDebrisCount; // 0A4 - std::int8_t onCrippleDecalCount; // 0A5 - BGSExplosion* dismemberExplosion; // 0A8 - BGSDebris* dismemberGenericDebris; // 0B0 - BGSImpactDataSet* dismemberImpactDataSet; // 0B8 - float dismemberGenericDebrisScale; // 0C0 - std::int8_t dismemberGenericDebrisCount; // 0C4 - std::int8_t dismemberDecalCount; // 0C5 - BGSExplosion* explosion; // 0C8 - BGSDebris* explosionGenericDebris; // 0D0 - BGSImpactDataSet* explosionImpactDataSet; // 0D8 - float explosionGenericDebrisScale; // 0E0 - std::int8_t explosionGenericDebrisCount; // 0E4 - std::int8_t explosionDecalCount; // 0E5 - BGSExplosion* subsegmentExplosion; // 0E8 - float maxPitch; // 0F0 - float maxRoll; // 0F4 - float defaultHeadHeight; // 0F8 + float height[2]; // 000 + NiPoint3 weight[2]; // 008 + std::int32_t flags; // 020 + float accelerate; // 024 + float decelerate; // 028 + REX::EnumSet raceSize; // 02C + REX::EnumSet headObject; // 030 + REX::EnumSet hairObject; // 034 + REX::EnumSet beardObject; // 038 + float injuredHealthPercent; // 03C + REX::EnumSet shieldObject; // 040 + REX::EnumSet bodyObject; // 044 + float aimAngleTolerance; // 048 + float flightRadius; // 04C + float angleAccelerate; // 050 + float angleTolerance; // 054 + std::uint32_t flags2; // 058 + NiPoint3 mountOffset; // 05C + NiPoint3 dismountOffset; // 068 + NiPoint3 mountCameraOffset; // 074 + REX::EnumSet pipboyObject; // 080 + std::int16_t xpValue; // 084 + BGSExplosion* onCrippleExplosion; // 088 + BGSDebris* onCrippleGenericDebris; // 090 + BGSImpactDataSet* onCrippleImpactDataSet; // 098 + float onCrippleGenericDebrisScale; // 0A0 + std::int8_t onCrippleGenericDebrisCount; // 0A4 + std::int8_t onCrippleDecalCount; // 0A5 + BGSExplosion* dismemberExplosion; // 0A8 + BGSDebris* dismemberGenericDebris; // 0B0 + BGSImpactDataSet* dismemberImpactDataSet; // 0B8 + float dismemberGenericDebrisScale; // 0C0 + std::int8_t dismemberGenericDebrisCount; // 0C4 + std::int8_t dismemberDecalCount; // 0C5 + BGSExplosion* explosion; // 0C8 + BGSDebris* explosionGenericDebris; // 0D0 + BGSImpactDataSet* explosionImpactDataSet; // 0D8 + float explosionGenericDebrisScale; // 0E0 + std::int8_t explosionGenericDebrisCount; // 0E4 + std::int8_t explosionDecalCount; // 0E5 + BGSExplosion* subsegmentExplosion; // 0E8 + float maxPitch; // 0F0 + float maxRoll; // 0F4 + float defaultHeadHeight; // 0F8 }; static_assert(sizeof(RACE_DATA) == 0x100); diff --git a/CommonLibF4/include/RE/Bethesda/TESWorldSpace.h b/CommonLibF4/include/RE/Bethesda/TESWorldSpace.h index dc34d4ed..1d5b59e1 100644 --- a/CommonLibF4/include/RE/Bethesda/TESWorldSpace.h +++ b/CommonLibF4/include/RE/Bethesda/TESWorldSpace.h @@ -128,7 +128,7 @@ namespace RE BGSTerrainManager* terrainManager; // 078 TESClimate* climate; // 080 std::int8_t flags; // 088 - stl::enumeration parentUseFlags; // 08A + REX::EnumSet parentUseFlags; // 08A std::int8_t worldFlags; // 08C ShortPoint fixedCenter; // 08E BSTHashMap>*> fixedPersistentRefMap; // 098 diff --git a/CommonLibF4/include/RE/Bethesda/UIMessage.h b/CommonLibF4/include/RE/Bethesda/UIMessage.h index d2b032ab..20e9ce8c 100644 --- a/CommonLibF4/include/RE/Bethesda/UIMessage.h +++ b/CommonLibF4/include/RE/Bethesda/UIMessage.h @@ -52,8 +52,8 @@ namespace RE F4_HEAP_REDEFINE_NEW(UIMessage); // members - BSFixedString menu; // 08 - stl::enumeration type{ UI_MESSAGE_TYPE::kTotal }; // 10 + BSFixedString menu; // 08 + REX::EnumSet type{ UI_MESSAGE_TYPE::kTotal }; // 10 }; static_assert(sizeof(UIMessage) == 0x18); diff --git a/CommonLibF4/include/RE/Bethesda/UIShaderFXInfo.h b/CommonLibF4/include/RE/Bethesda/UIShaderFXInfo.h index 96300d7d..aea22e52 100644 --- a/CommonLibF4/include/RE/Bethesda/UIShaderFXInfo.h +++ b/CommonLibF4/include/RE/Bethesda/UIShaderFXInfo.h @@ -17,11 +17,11 @@ namespace RE }; // members - NiRect backgroundQuad; // 00 - NiColorA backgroundColor; // 10 - NiColorA colorMultipliers; // 20 - float colorBrightness; // 30 - stl::enumeration enabledStates; // 34 + NiRect backgroundQuad; // 00 + NiColorA backgroundColor; // 10 + NiColorA colorMultipliers; // 20 + float colorBrightness; // 30 + REX::EnumSet enabledStates; // 34 }; static_assert(sizeof(UIShaderColors) == 0x38); diff --git a/CommonLibF4/include/RE/Bethesda/VATS.h b/CommonLibF4/include/RE/Bethesda/VATS.h index 744f7345..7e3dbf7d 100644 --- a/CommonLibF4/include/RE/Bethesda/VATS.h +++ b/CommonLibF4/include/RE/Bethesda/VATS.h @@ -53,33 +53,33 @@ namespace RE } // members - BSTArray> commands; // 28 - stl::enumeration mode; // 40 - VATSCameraContext* cameraContext; // 48 - float castingAfterKillDelay; // 50 - NiPointer firstProjectile; // 58 - NiPointer lastProjectile; // 60 - float fakeShotCounter; // 68 - TESIdleForm* meleeAttack; // 70 - NiPointer VATSLight; // 78 - std::int32_t killCount; // 80 - float magicTimeSlowdown; // 84 - float playerMagicTimeSlowdown; // 88 - NiPointer VATSTarget; // 90 - NiPointer VATSAttacker; // 98 - NiPointer stranger; // A0 - NiPointer predictionProjectile; // A8 - BSTSmartPointer reloadCommand; // B0 - BSTSmartPointer sightedCommand; // B8 - float VATSPlaybackTimer; // C0 - float VATSCommandTimer; // C4 - bool projectileNearTarget; // C8 - bool applyCritical; // C9 - bool firstAttackExecuted; // CA - bool firstAttackFired; // CB - bool readyForShutdown; // CC - bool wantsStranger; // CD - BSSpinLock spinLock; // D0 + BSTArray> commands; // 28 + REX::EnumSet mode; // 40 + VATSCameraContext* cameraContext; // 48 + float castingAfterKillDelay; // 50 + NiPointer firstProjectile; // 58 + NiPointer lastProjectile; // 60 + float fakeShotCounter; // 68 + TESIdleForm* meleeAttack; // 70 + NiPointer VATSLight; // 78 + std::int32_t killCount; // 80 + float magicTimeSlowdown; // 84 + float playerMagicTimeSlowdown; // 88 + NiPointer VATSTarget; // 90 + NiPointer VATSAttacker; // 98 + NiPointer stranger; // A0 + NiPointer predictionProjectile; // A8 + BSTSmartPointer reloadCommand; // B0 + BSTSmartPointer sightedCommand; // B8 + float VATSPlaybackTimer; // C0 + float VATSCommandTimer; // C4 + bool projectileNearTarget; // C8 + bool applyCritical; // C9 + bool firstAttackExecuted; // CA + bool firstAttackFired; // CB + bool readyForShutdown; // CC + bool wantsStranger; // CD + BSSpinLock spinLock; // D0 }; static_assert(sizeof(VATS) == 0xD8); } diff --git a/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h b/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h index 4e0f3ec5..3eda036d 100644 --- a/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h +++ b/CommonLibF4/include/RE/Bethesda/bhkCharacterController.h @@ -214,78 +214,78 @@ namespace RE virtual void ClearCollectorDataImpl() = 0; // 4C // members - hkVector4f forwardVec; // 140 - hkStepInfo stepInfo; // 150 - hkVector4f outVelocity; // 160 - hkVector4f initialVelocity; // 170 - hkVector4f velocityMod; // 180 - hkVector4f direction; // 190 - hkVector4f rotCenter; // 1A0 - hkVector4f pushDelta; // 1B0 - hkVector4f fakeSupportStart; // 1C0 - hkVector4f up; // 1D0 - hkVector4f supportNorm; // 1E0 - BSBound collisionBound; // 1F0 - BSBound bumperCollisionBound; // 220 - NiPoint3 cachedLinearVelocity; // 250 - NiPoint3 remainderDeltaWS; // 24C - bhkICharOrientationController* orientationCtrl; // 268 - hknpCharacterSurfaceInfo surfaceInfo; // 270 - hknpCharacterContext context; // 2A0 - std::uint32_t flags; // 300 - stl::enumeration wantState; // 304 - float velocityTime; // 308 - float rotMod; // 30C - float rotModTime; // 310 - float calculatePitchTimer; // 314 - float acrobatics; // 318 - float center; // 31C - float waterHeight; // 320 - float jumpHeight; // 324 - float fallStartHeight; // 328 - float fallTime; // 32C - float gravity; // 330 - float pitchAngle; // 334 - float rollAngle; // 338 - float pitchMult; // 33C - float scale; // 340 - float swimFloatHeight; // 344 - float actorHeight; // 348 - float speedPct; // 34C - std::uint32_t pushCount; // 350 - stl::enumeration shapeType; // 354 - stl::enumeration sizedShapeType; // 358 - hkRefPtr shapes[2]; // 360 - float radius; // 370 - float height; // 374 - float destRadius; // 378 - float lodDistance; // 37C - stl::enumeration size; // 380 - std::uint32_t priority; // 384 - std::int32_t supportCount; // 388 - NiPointer supportBody; // 390 - float bumpedForce; // 398 - NiPointer bumpedBody; // 3A0 - NiPointer bumpedCharCollisionObject; // 3A8 - BSTHashMap bumpedBodyIdExpirationM; // 3B0 - void* userData; // 3E0 - BSTHashMap damageImpacts; // 3E8 - float maxSlope; // 418 - std::uint32_t supportMaterial; // 41C - stl::enumeration supportLayer; // 420 - float stepHeight; // 424 - float stepHeightMod; // 428 - float stepHeightModTimer; // 42C - const float castDepthC; // 430 - std::uint32_t numCollisions; // 434 - std::uint32_t stickyCollisionGroup; // 438 - bool allSurfacesStopped; // 43C - bool stickyCollisions; // 43D - bool fakeSupport; // 43E - bool calculatePitch; // 43F - bool useBumper; // 440 - bool hasBumper; // 441 - bool inAirPreMove; // 442 + hkVector4f forwardVec; // 140 + hkStepInfo stepInfo; // 150 + hkVector4f outVelocity; // 160 + hkVector4f initialVelocity; // 170 + hkVector4f velocityMod; // 180 + hkVector4f direction; // 190 + hkVector4f rotCenter; // 1A0 + hkVector4f pushDelta; // 1B0 + hkVector4f fakeSupportStart; // 1C0 + hkVector4f up; // 1D0 + hkVector4f supportNorm; // 1E0 + BSBound collisionBound; // 1F0 + BSBound bumperCollisionBound; // 220 + NiPoint3 cachedLinearVelocity; // 250 + NiPoint3 remainderDeltaWS; // 24C + bhkICharOrientationController* orientationCtrl; // 268 + hknpCharacterSurfaceInfo surfaceInfo; // 270 + hknpCharacterContext context; // 2A0 + std::uint32_t flags; // 300 + REX::EnumSet wantState; // 304 + float velocityTime; // 308 + float rotMod; // 30C + float rotModTime; // 310 + float calculatePitchTimer; // 314 + float acrobatics; // 318 + float center; // 31C + float waterHeight; // 320 + float jumpHeight; // 324 + float fallStartHeight; // 328 + float fallTime; // 32C + float gravity; // 330 + float pitchAngle; // 334 + float rollAngle; // 338 + float pitchMult; // 33C + float scale; // 340 + float swimFloatHeight; // 344 + float actorHeight; // 348 + float speedPct; // 34C + std::uint32_t pushCount; // 350 + REX::EnumSet shapeType; // 354 + REX::EnumSet sizedShapeType; // 358 + hkRefPtr shapes[2]; // 360 + float radius; // 370 + float height; // 374 + float destRadius; // 378 + float lodDistance; // 37C + REX::EnumSet size; // 380 + std::uint32_t priority; // 384 + std::int32_t supportCount; // 388 + NiPointer supportBody; // 390 + float bumpedForce; // 398 + NiPointer bumpedBody; // 3A0 + NiPointer bumpedCharCollisionObject; // 3A8 + BSTHashMap bumpedBodyIdExpirationM; // 3B0 + void* userData; // 3E0 + BSTHashMap damageImpacts; // 3E8 + float maxSlope; // 418 + std::uint32_t supportMaterial; // 41C + REX::EnumSet supportLayer; // 420 + float stepHeight; // 424 + float stepHeightMod; // 428 + float stepHeightModTimer; // 42C + const float castDepthC; // 430 + std::uint32_t numCollisions; // 434 + std::uint32_t stickyCollisionGroup; // 438 + bool allSurfacesStopped; // 43C + bool stickyCollisions; // 43D + bool fakeSupport; // 43E + bool calculatePitch; // 43F + bool useBumper; // 440 + bool hasBumper; // 441 + bool inAirPreMove; // 442 }; static_assert(sizeof(bhkCharacterController) == 0x450); } diff --git a/CommonLibF4/include/RE/Havok/hkBaseTypes.h b/CommonLibF4/include/RE/Havok/hkBaseTypes.h index bb6648c8..d65e0b9b 100644 --- a/CommonLibF4/include/RE/Havok/hkBaseTypes.h +++ b/CommonLibF4/include/RE/Havok/hkBaseTypes.h @@ -11,10 +11,10 @@ namespace RE }; template - using hkEnum = stl::enumeration; + using hkEnum = REX::EnumSet; template - using hkFlags = stl::enumeration; + using hkFlags = REX::EnumSet; template class hkPadSpu diff --git a/CommonLibF4/include/RE/Havok/hknpCharacterContext.h b/CommonLibF4/include/RE/Havok/hknpCharacterContext.h index 38e7e1fd..4df4d39d 100644 --- a/CommonLibF4/include/RE/Havok/hknpCharacterContext.h +++ b/CommonLibF4/include/RE/Havok/hknpCharacterContext.h @@ -23,16 +23,16 @@ namespace RE }; // members - stl::enumeration characterType; // 10 - hknpCharacterStateManager* stateManager; // 18 - stl::enumeration currentState; // 20 - stl::enumeration previousState; // 24 - hkBool filterEnable; // 28 - float maxLinearAcceleration; // 2C - float maxLinearSpeed; // 30 - float gain; // 34 - hkVector4f previousSurfaceVelocity; // 40 - std::int32_t numUpdatesInCurrentState; // 50 + REX::EnumSet characterType; // 10 + hknpCharacterStateManager* stateManager; // 18 + REX::EnumSet currentState; // 20 + REX::EnumSet previousState; // 24 + hkBool filterEnable; // 28 + float maxLinearAcceleration; // 2C + float maxLinearSpeed; // 30 + float gain; // 34 + hkVector4f previousSurfaceVelocity; // 40 + std::int32_t numUpdatesInCurrentState; // 50 }; static_assert(sizeof(hknpCharacterContext) == 0x60); } diff --git a/CommonLibF4/include/RE/Havok/hknpCollisionResult.h b/CommonLibF4/include/RE/Havok/hknpCollisionResult.h index 2cf334eb..ccd27b95 100644 --- a/CommonLibF4/include/RE/Havok/hknpCollisionResult.h +++ b/CommonLibF4/include/RE/Havok/hknpCollisionResult.h @@ -29,13 +29,13 @@ namespace RE static_assert(sizeof(BodyInfo) == 0x18); // members - hkVector4f position; // 00 - hkVector4f normal; // 10 - hkPadSpu fraction; // 20 - BodyInfo queryBodyInfo; // 28 - BodyInfo hitBodyInfo; // 40 - stl::enumeration queryType; // 58 - hkPadSpu hitResult; // 5C + hkVector4f position; // 00 + hkVector4f normal; // 10 + hkPadSpu fraction; // 20 + BodyInfo queryBodyInfo; // 28 + BodyInfo hitBodyInfo; // 40 + REX::EnumSet queryType; // 58 + hkPadSpu hitResult; // 5C }; static_assert(sizeof(hknpCollisionResult) == 0x60); } diff --git a/CommonLibF4/include/RE/NetImmerse/NiCloningProcess.h b/CommonLibF4/include/RE/NetImmerse/NiCloningProcess.h index 78b7ec44..5bd9e5c8 100644 --- a/CommonLibF4/include/RE/NetImmerse/NiCloningProcess.h +++ b/CommonLibF4/include/RE/NetImmerse/NiCloningProcess.h @@ -18,11 +18,11 @@ namespace RE }; // members - BSTHashMap cloneMap; // 00 - BSTHashMap processMap; // 30 - stl::enumeration copyType; // 60 - char appendChar; // 64 - NiPoint3 scale; // 68 + BSTHashMap cloneMap; // 00 + BSTHashMap processMap; // 30 + REX::EnumSet copyType; // 60 + char appendChar; // 64 + NiPoint3 scale; // 68 }; static_assert(sizeof(NiCloningProcess) == 0x78); } diff --git a/CommonLibF4/include/RE/NetImmerse/NiController.h b/CommonLibF4/include/RE/NetImmerse/NiController.h index 99a58226..2591342b 100644 --- a/CommonLibF4/include/RE/NetImmerse/NiController.h +++ b/CommonLibF4/include/RE/NetImmerse/NiController.h @@ -97,7 +97,7 @@ namespace RE float weightedLastTime; // 54 float lastScaledTime; // 58 NiControllerManager* owner; // 60 - stl::enumeration state; // 68 + REX::EnumSet state; // 68 float offset; // 6C float startTime; // 70 float endTime; // 74 diff --git a/CommonLibF4/include/RE/NetImmerse/NiFile.h b/CommonLibF4/include/RE/NetImmerse/NiFile.h index 791c9df5..dffef38f 100644 --- a/CommonLibF4/include/RE/NetImmerse/NiFile.h +++ b/CommonLibF4/include/RE/NetImmerse/NiFile.h @@ -21,14 +21,14 @@ namespace RE }; // members - std::size_t bufferAllocSize; // 10 - std::size_t bufferReadSize; // 18 - std::size_t pos; // 20 - std::size_t currentFilePos; // 28 - char* buffer; // 30 - BSSystemFile systemFile; // 38 - stl::enumeration mode; // 48 - bool good; // 4C + std::size_t bufferAllocSize; // 10 + std::size_t bufferReadSize; // 18 + std::size_t pos; // 20 + std::size_t currentFilePos; // 28 + char* buffer; // 30 + BSSystemFile systemFile; // 38 + REX::EnumSet mode; // 48 + bool good; // 4C }; static_assert(sizeof(NiFile) == 0x50); } diff --git a/CommonLibF4/include/RE/RTTI.h b/CommonLibF4/include/RE/RTTI.h index 4f0ae77b..47f56bc7 100644 --- a/CommonLibF4/include/RE/RTTI.h +++ b/CommonLibF4/include/RE/RTTI.h @@ -65,10 +65,10 @@ namespace RE }; // members - RVA typeDescriptor; // 00 - std::uint32_t numContainedBases; // 04 - PMD pmd; // 08 - stl::enumeration attributes; // 14 + RVA typeDescriptor; // 00 + std::uint32_t numContainedBases; // 04 + PMD pmd; // 08 + REX::EnumSet attributes; // 14 }; static_assert(sizeof(BaseClassDescriptor) == 0x18); @@ -84,10 +84,10 @@ namespace RE }; // members - std::uint32_t signature; // 00 - stl::enumeration attributes; // 04 - std::uint32_t numBaseClasses; // 08 - RVA baseClassArray; // 0C + std::uint32_t signature; // 00 + REX::EnumSet attributes; // 04 + std::uint32_t numBaseClasses; // 08 + RVA baseClassArray; // 0C }; static_assert(sizeof(ClassHierarchyDescriptor) == 0x10); @@ -101,11 +101,11 @@ namespace RE }; // members - stl::enumeration signature; // 00 - std::uint32_t offset; // 04 - std::uint32_t ctorDispOffset; // 08 - RVA typeDescriptor; // 0C - RVA classDescriptor; // 10 + REX::EnumSet signature; // 00 + std::uint32_t offset; // 04 + std::uint32_t ctorDispOffset; // 08 + RVA typeDescriptor; // 0C + RVA classDescriptor; // 10 }; static_assert(sizeof(CompleteObjectLocator) == 0x14); } diff --git a/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h b/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h index c44d8ddf..a2e59859 100644 --- a/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h +++ b/CommonLibF4/include/RE/Scaleform/GFx/GFx_Player.h @@ -1006,10 +1006,10 @@ namespace RE::Scaleform::GFx } // members - ObjectInterface* _objectInterface{ nullptr }; // 00 - stl::enumeration _type{ ValueType::kUndefined }; // 08 - ValueUnion _value{}; // 10 - std::size_t _dataAux{ 0 }; // 18 + ObjectInterface* _objectInterface{ nullptr }; // 00 + REX::EnumSet _type{ ValueType::kUndefined }; // 08 + ValueUnion _value{}; // 10 + std::size_t _dataAux{ 0 }; // 18 }; static_assert(sizeof(Value) == 0x20); diff --git a/CommonLibF4/include/RE/Scaleform/Kernel/SF_Types.h b/CommonLibF4/include/RE/Scaleform/Kernel/SF_Types.h index fe833567..4973930a 100644 --- a/CommonLibF4/include/RE/Scaleform/Kernel/SF_Types.h +++ b/CommonLibF4/include/RE/Scaleform/Kernel/SF_Types.h @@ -3,5 +3,5 @@ namespace RE::Scaleform { template > - using Flags = stl::enumeration; + using Flags = REX::EnumSet; } diff --git a/CommonLibF4/include/RE/Scaleform/Render/Render_Context.h b/CommonLibF4/include/RE/Scaleform/Render/Render_Context.h index 837c1841..9ff8fe3f 100644 --- a/CommonLibF4/include/RE/Scaleform/Render/Render_Context.h +++ b/CommonLibF4/include/RE/Scaleform/Render/Render_Context.h @@ -55,9 +55,9 @@ namespace RE::Scaleform::Render { public: // members - Ptr contextLock; // 20 - stl::enumeration state; // 28 - Entry* entry; // 30 + Ptr contextLock; // 20 + REX::EnumSet state; // 28 + Entry* entry; // 30 }; static_assert(sizeof(HandleData) == 0x38); @@ -134,8 +134,8 @@ namespace RE::Scaleform::Render virtual bool PropagateUp(Entry* a_entry) const; // 05 // members - stl::enumeration type; // 08 - std::uint16_t flags; // 0A + REX::EnumSet type; // 08 + std::uint16_t flags; // 0A }; static_assert(sizeof(EntryData) == 0x10); diff --git a/CommonLibF4/include/RE/Scaleform/Render/Render_Viewport.h b/CommonLibF4/include/RE/Scaleform/Render/Render_Viewport.h index 8d986a09..a2bb4c57 100644 --- a/CommonLibF4/include/RE/Scaleform/Render/Render_Viewport.h +++ b/CommonLibF4/include/RE/Scaleform/Render/Render_Viewport.h @@ -34,17 +34,17 @@ namespace RE::Scaleform::Render }; // members - std::int32_t bufferWidth; // 00 - std::int32_t bufferHeight; // 04 - std::int32_t left; // 08 - std::int32_t top; // 0C - std::int32_t width; // 10 - std::int32_t height; // 14 - std::int32_t scissorLeft; // 18 - std::int32_t scissorTop; // 1C - std::int32_t scissorWidth; // 20 - std::int32_t scissorHeight; // 24 - stl::enumeration flags; // 28 + std::int32_t bufferWidth; // 00 + std::int32_t bufferHeight; // 04 + std::int32_t left; // 08 + std::int32_t top; // 0C + std::int32_t width; // 10 + std::int32_t height; // 14 + std::int32_t scissorLeft; // 18 + std::int32_t scissorTop; // 1C + std::int32_t scissorWidth; // 20 + std::int32_t scissorHeight; // 24 + REX::EnumSet flags; // 28 }; static_assert(sizeof(Viewport) == 0x2C); } From f927a914dd0ee22b6a318d37d57903ad3591f7d7 Mon Sep 17 00:00:00 2001 From: Qudix <17361645+Qudix@users.noreply.github.com> Date: Tue, 28 May 2024 11:38:21 -0500 Subject: [PATCH 5/5] feat: add `Singleton` class to `REX` --- CommonLibF4/include/REX/REX.h | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/CommonLibF4/include/REX/REX.h b/CommonLibF4/include/REX/REX.h index 9bdc966f..b7b8aa04 100644 --- a/CommonLibF4/include/REX/REX.h +++ b/CommonLibF4/include/REX/REX.h @@ -167,3 +167,27 @@ namespace REX std::underlying_type_t< std::common_type_t>>; } + +namespace REX +{ + template + class Singleton + { + public: + static T* GetSingleton() + { + static T singleton; + return std::addressof(singleton); + } + + protected: + Singleton() = default; + ~Singleton() = default; + + Singleton(const Singleton&) = delete; + Singleton(Singleton&&) = delete; + + Singleton& operator=(const Singleton&) = delete; + Singleton& operator=(Singleton&&) = delete; + }; +}