mirror of
https://github.com/zeldaret/botw
synced 2026-08-20 05:46:16 -04:00
ksys/gdt: Implement more TriggerParam functions
This commit is contained in:
Léo Lam
@@ -1,6 +1,7 @@
|
||||
target_sources(uking PRIVATE
|
||||
gdtFlag.cpp
|
||||
gdtFlag.h
|
||||
gdtFlagProxy.h
|
||||
gdtManager.cpp
|
||||
gdtManager.h
|
||||
gdtTriggerParam.cpp
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
#include <prim/seadSafeString.h>
|
||||
#include <prim/seadSizedEnum.h>
|
||||
#include <type_traits>
|
||||
#include "KingSystem/Utils/TypeTraits.h"
|
||||
#include "KingSystem/Utils/Types.h"
|
||||
|
||||
namespace al {
|
||||
@@ -28,6 +29,10 @@ enum class ResetType {
|
||||
ResetOnAnimalMasterAppearance = 4,
|
||||
};
|
||||
|
||||
constexpr bool isResettableFlag(ResetType type) {
|
||||
return type > ResetType::NoReset;
|
||||
}
|
||||
|
||||
struct FlagDebugData {
|
||||
sead::SafeString name;
|
||||
s32 delete_rev = 0;
|
||||
@@ -87,6 +92,27 @@ SEAD_ENUM(FlagType, Bool = 0, S32 = 1, F32 = 2, String = 3, String64 = 4, String
|
||||
StringArray = 12, String64Array = 13, String256Array = 14, Vector2fArray = 15,
|
||||
Vector3fArray = 16, Vector4fArray = 17, Invalid = 18)
|
||||
|
||||
template <typename T>
|
||||
constexpr bool isValidFlagArrayType() {
|
||||
return IsAnyOfType<T, sead::Buffer<bool>, sead::Buffer<s32>, sead::Buffer<f32>,
|
||||
sead::Buffer<sead::FixedSafeString<32>>,
|
||||
sead::Buffer<sead::FixedSafeString<64>>,
|
||||
sead::Buffer<sead::FixedSafeString<256>>, sead::Buffer<sead::Vector2f>,
|
||||
sead::Buffer<sead::Vector3f>, sead::Buffer<sead::Vector4f>>();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr bool isValidFlagValueType() {
|
||||
return IsAnyOfType<T, bool, s32, f32, sead::FixedSafeString<32>, sead::FixedSafeString<64>,
|
||||
sead::FixedSafeString<256>, sead::Vector2f, sead::Vector3f,
|
||||
sead::Vector4f>();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr bool isValidFlagType() {
|
||||
return isValidFlagValueType<T>() || isValidFlagArrayType<T>();
|
||||
}
|
||||
|
||||
class FlagBase {
|
||||
public:
|
||||
virtual ~FlagBase() = 0;
|
||||
@@ -109,6 +135,15 @@ public:
|
||||
virtual const sead::SafeString& getName() const = 0;
|
||||
virtual s32 getDeleteRev() const = 0;
|
||||
|
||||
virtual u32 getRandomResetData() const = 0;
|
||||
|
||||
bool isResettable() const { return isResettableFlag(getProperties().getResetType()); }
|
||||
|
||||
bool isPermanent() const {
|
||||
return getProperties().isSave() && getProperties().getResetType() == ResetType::NoReset &&
|
||||
getRandomResetData() == 0;
|
||||
}
|
||||
|
||||
protected:
|
||||
s32 clampValue_(const s32& min_value, s32* value, const s32& max_value);
|
||||
s32 clampValue_(const f32& min_value, f32* value, const f32& max_value);
|
||||
@@ -151,7 +186,7 @@ public:
|
||||
using ConfigType = FlagConfig<T>;
|
||||
using RawValueType = std::conditional_t<std::is_same_v<T, bool>, u8, T>;
|
||||
|
||||
virtual u32 getRandomResetData() const;
|
||||
u32 getRandomResetData() const override;
|
||||
|
||||
virtual const ConfigType& getConfig() const = 0;
|
||||
virtual void setConfig(const ConfigType& config) = 0;
|
||||
|
||||
@@ -0,0 +1,148 @@
|
||||
#pragma once
|
||||
|
||||
#include "KingSystem/GameData/gdtFlag.h"
|
||||
|
||||
namespace ksys::gdt {
|
||||
|
||||
template <typename T>
|
||||
class FlagProxy : public FlagT<T> {
|
||||
public:
|
||||
using ConfigType = FlagConfig<T>;
|
||||
using RawValueType = typename Flag<T>::RawValueType;
|
||||
|
||||
FlagProxy() = default;
|
||||
explicit FlagProxy(Flag<T>* flag) : mFlag(flag) {}
|
||||
~FlagProxy() override = default;
|
||||
|
||||
Flag<T>* getFlag() const { return mFlag; }
|
||||
void setFlag(Flag<T>* flag) { mFlag = flag; }
|
||||
|
||||
u32 getHash() const override { return mFlag->getHash(); }
|
||||
void setHash(u32 hash) override { mFlag->setHash(hash); }
|
||||
|
||||
FlagType getType() const override { return mFlag->getType(); }
|
||||
void setType(FlagType type) override { mFlag->setType(type); }
|
||||
|
||||
const FlagProperties& getProperties() const override { return mFlag->getProperties(); }
|
||||
void setProperties(const FlagProperties& properties) override {
|
||||
mFlag->setProperties(properties);
|
||||
}
|
||||
|
||||
void resetToInitialValue() override;
|
||||
bool isInitialValue() const override;
|
||||
|
||||
u32 getCategory() const override;
|
||||
void setCategory(u32 category) override;
|
||||
|
||||
const sead::SafeString& getName() const override { return mFlag->getName(); }
|
||||
s32 getDeleteRev() const override { return mFlag->getDeleteRev(); }
|
||||
|
||||
const ConfigType& getConfig() const override { return mFlag->getConfig(); }
|
||||
void setConfig(const ConfigType& config) override { mFlag->setConfig(config); }
|
||||
|
||||
T getValue() const override;
|
||||
|
||||
RawValueType& getValueRef() override;
|
||||
const RawValueType& getValueRef() const override;
|
||||
|
||||
bool hasValue(const T& value) const override;
|
||||
bool setValue(T value) override;
|
||||
|
||||
FlagDebugData* getDebugData() const override { return mFlag->getDebugData(); }
|
||||
void setDebugData(FlagDebugData* data) { mFlag->setDebugData(data); }
|
||||
|
||||
private:
|
||||
Flag<T>* mFlag = nullptr;
|
||||
RawValueType mValue{};
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
inline void FlagProxy<T>::resetToInitialValue() {
|
||||
if constexpr (std::is_same<T, bool>()) {
|
||||
const auto category = getCategory();
|
||||
mValue = getConfig().initial_value & 1;
|
||||
setCategory(category);
|
||||
} else {
|
||||
mValue = getConfig().initial_value;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool FlagProxy<T>::isInitialValue() const {
|
||||
if constexpr (std::is_same<T, bool>()) {
|
||||
const bool initial_value = getConfig().initial_value & 1;
|
||||
return getValue() == initial_value;
|
||||
} else {
|
||||
T initial_value;
|
||||
initial_value = getConfig().initial_value;
|
||||
return getValue() == initial_value;
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline u32 FlagProxy<T>::getCategory() const {
|
||||
if (!this->isBoolean_())
|
||||
return 0;
|
||||
return this->getCategoryForBool_(&mValue);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline void FlagProxy<T>::setCategory(u32 category) {
|
||||
if (!this->isBoolean_())
|
||||
return;
|
||||
this->setCategoryForBool_(&mValue, category);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline T FlagProxy<T>::getValue() const {
|
||||
if constexpr (std::is_same<T, bool>())
|
||||
return mValue & 1;
|
||||
else
|
||||
return mValue;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline typename FlagProxy<T>::RawValueType& FlagProxy<T>::getValueRef() {
|
||||
return mValue;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline const typename FlagProxy<T>::RawValueType& FlagProxy<T>::getValueRef() const {
|
||||
return mValue;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool FlagProxy<T>::hasValue(const T& value) const {
|
||||
return value == getValue();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline bool FlagProxy<T>::setValue(T value) {
|
||||
if constexpr (std::is_same<T, bool>()) {
|
||||
if (value == getValue())
|
||||
return false;
|
||||
|
||||
if (value)
|
||||
mValue |= 1;
|
||||
else
|
||||
mValue &= ~1;
|
||||
|
||||
return true;
|
||||
} else {
|
||||
[[maybe_unused]] const T new_value = value;
|
||||
|
||||
T min_value;
|
||||
T max_value;
|
||||
min_value = getConfig().min_value;
|
||||
max_value = getConfig().max_value;
|
||||
this->clampValue_(min_value, &value, max_value);
|
||||
|
||||
if (mValue != value) {
|
||||
mValue = value;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace ksys::gdt
|
||||
@@ -1,11 +1,930 @@
|
||||
#include "KingSystem/GameData/gdtTriggerParam.h"
|
||||
#include <algorithm>
|
||||
#include "KingSystem/GameData/gdtFlagProxy.h"
|
||||
#include "KingSystem/Resource/resResourceGameData.h"
|
||||
#include "KingSystem/Utils/SafeDelete.h"
|
||||
|
||||
namespace ksys::gdt {
|
||||
|
||||
TriggerParam::TriggerParam() {
|
||||
mUnkArray.constructDefault();
|
||||
mCriticalSections.constructDefault();
|
||||
mFlags.constructDefault();
|
||||
mBitFlags.constructDefault();
|
||||
mCounts.fill(0);
|
||||
mNumBoolFlagsPerCategory.fill(0);
|
||||
}
|
||||
|
||||
namespace {
|
||||
// TODO (low-priority): implement this without using <algorithm> to match the original code
|
||||
// The original code appears to perform a heapsort.
|
||||
[[gnu::noinline]] void sortFlagPtrArray(sead::PtrArray<FlagBase>& array) {
|
||||
std::sort(array.dataBegin(), array.dataEnd(),
|
||||
[](const FlagBase* a, const FlagBase* b) { return a->getHash() < b->getHash(); });
|
||||
}
|
||||
|
||||
inline s32 getFlagIndex(const sead::PtrArray<FlagBase>& flags, u32 name_hash) {
|
||||
s32 a = 0;
|
||||
s32 b = flags.size() - 1;
|
||||
while (a < b) {
|
||||
const s32 m = (a + b) / 2;
|
||||
if (flags[m]->getHash() == name_hash)
|
||||
return m;
|
||||
if (flags[m]->getHash() < name_hash)
|
||||
a = m + 1;
|
||||
else
|
||||
b = m;
|
||||
}
|
||||
|
||||
if (flags[a]->getHash() == name_hash)
|
||||
return a;
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
inline s32 getFlagIndex(const sead::PtrArray<sead::PtrArray<FlagBase>>& flags, u32 name_hash) {
|
||||
for (s32 i = 0; i < flags.size(); ++i) {
|
||||
const auto& array = *flags[i];
|
||||
if (array.size() > 0 && array[0]->getHash() == name_hash)
|
||||
return i;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline Flag<T>* getFlagByIndex(const sead::PtrArray<FlagBase>& flags, s32 index) {
|
||||
if (index < 0 || index >= flags.size())
|
||||
return nullptr;
|
||||
return static_cast<Flag<T>*>(flags[index]);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline Flag<T>* getFlag(const sead::PtrArray<FlagBase>& flags, u32 name_hash) {
|
||||
return getFlagByIndex<T>(flags, getFlagIndex(flags, name_hash));
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline Flag<T>* getFlag(const sead::PtrArray<FlagBase>& flags, const sead::SafeString& name) {
|
||||
if (name.isEmpty())
|
||||
return nullptr;
|
||||
return getFlag<T>(flags, sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
|
||||
template <typename T, typename FlagValueType = T>
|
||||
inline bool getFlagValue(const sead::PtrArray<FlagBase>& array, T* out_value, s32 index,
|
||||
bool check_permissions) {
|
||||
static_assert(isValidFlagValueType<FlagValueType>());
|
||||
|
||||
const auto* flag = getFlagByIndex<FlagValueType>(array, index);
|
||||
if (!flag)
|
||||
return false;
|
||||
|
||||
if (check_permissions && !flag->getProperties().isProgramReadable())
|
||||
return false;
|
||||
|
||||
if constexpr (std::is_same<T, const char*>())
|
||||
*out_value = flag->getValueRef().cstr();
|
||||
else
|
||||
*out_value = flag->getValue();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T, typename FlagValueType = T>
|
||||
inline bool getFlagValue(const sead::PtrArray<sead::PtrArray<FlagBase>>& arrays, T* out_value,
|
||||
s32 array_index, s32 flag_index, bool check_permissions) {
|
||||
static_assert(isValidFlagValueType<FlagValueType>());
|
||||
|
||||
if (array_index < 0 || array_index >= arrays.size())
|
||||
return false;
|
||||
|
||||
const auto* array = arrays[array_index];
|
||||
if (!array)
|
||||
return false;
|
||||
|
||||
const auto* flag = getFlagByIndex<FlagValueType>(*array, flag_index);
|
||||
if (!flag)
|
||||
return false;
|
||||
|
||||
if (check_permissions && !flag->getProperties().isProgramReadable())
|
||||
return false;
|
||||
|
||||
if constexpr (std::is_same<T, const char*>())
|
||||
*out_value = flag->getValueRef().cstr();
|
||||
else
|
||||
*out_value = flag->getValue();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool getFlagArraySize(const sead::PtrArray<sead::PtrArray<FlagBase>>& arrays, s32 index, s32* out) {
|
||||
if (index < 0 || index >= arrays.size())
|
||||
return false;
|
||||
*out = arrays[index]->size();
|
||||
return true;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline void copyGameDataResBuffer(sead::Buffer<T>& source, sead::PtrArray<FlagBase>& dest,
|
||||
sead::Heap* heap) {
|
||||
if (source.size() == 0)
|
||||
return;
|
||||
|
||||
if (!dest.isBufferReady())
|
||||
dest.allocBuffer(source.size(), heap);
|
||||
|
||||
for (auto& flag : source)
|
||||
dest.pushBack(&flag);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
inline void copyGameDataResBuffer(sead::PtrArray<sead::Buffer<T>>& source,
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>>& dest,
|
||||
sead::Heap* heap) {
|
||||
const auto n = source.capacity();
|
||||
if (n < 1)
|
||||
return;
|
||||
|
||||
if (!dest.isBufferReady())
|
||||
dest.allocBuffer(n, heap);
|
||||
|
||||
for (s32 i = 0; i < n; ++i) {
|
||||
dest.pushBack(new (heap) sead::PtrArray<FlagBase>);
|
||||
const auto num_flags = source[i]->size();
|
||||
|
||||
if (!dest[i]->isBufferReady())
|
||||
dest[i]->allocBuffer(num_flags, heap);
|
||||
|
||||
for (s32 j = 0; j < num_flags; ++j)
|
||||
dest[i]->pushBack(std::addressof((*source[i])[j]));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void makeFlagProxies(sead::PtrArray<FlagBase>& dest, const sead::PtrArray<FlagBase>& src, s32 count,
|
||||
sead::Heap* heap, bool permanent_flags_only) {
|
||||
for (s32 i = 0; i < count; ++i) {
|
||||
auto* flag = static_cast<Flag<T>*>(src[i]);
|
||||
if (!permanent_flags_only) {
|
||||
auto* proxy = new (heap) FlagProxy<T>;
|
||||
proxy->setFlag(flag);
|
||||
proxy->setValue(flag->getValue());
|
||||
proxy->setCategory(flag->getCategory());
|
||||
dest.pushBack(proxy);
|
||||
} else if (flag->isPermanent()) {
|
||||
auto* proxy = new (heap) FlagProxy<T>;
|
||||
proxy->setFlag(flag);
|
||||
proxy->setValue(flag->getValue());
|
||||
proxy->setCategory(flag->getCategory());
|
||||
dest.pushBack(proxy);
|
||||
}
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
void TriggerParam::copyFromGameDataRes(res::GameData* gdata, sead::Heap* heap) {
|
||||
if (!gdata)
|
||||
return;
|
||||
|
||||
copyGameDataResBuffer(gdata->getBoolFlags(), mBoolFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getS32Flags(), mS32Flags, heap);
|
||||
copyGameDataResBuffer(gdata->getF32Flags(), mF32Flags, heap);
|
||||
copyGameDataResBuffer(gdata->getStringFlags(), mStringFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getString64Flags(), mString64Flags, heap);
|
||||
copyGameDataResBuffer(gdata->getString256Flags(), mString256Flags, heap);
|
||||
copyGameDataResBuffer(gdata->getVector2fFlags(), mVector2fFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getVector3fFlags(), mVector3fFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getVector4fFlags(), mVector4fFlags, heap);
|
||||
|
||||
copyGameDataResBuffer(gdata->getBoolArrayFlags(), mBoolArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getS32ArrayFlags(), mS32ArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getF32ArrayFlags(), mF32ArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getStringArrayFlags(), mStringArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getString64ArrayFlags(), mString64ArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getString256ArrayFlags(), mString256ArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getVector2fArrayFlags(), mVector2fArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getVector3fArrayFlags(), mVector3fArrayFlags, heap);
|
||||
copyGameDataResBuffer(gdata->getVector4fArrayFlags(), mVector4fArrayFlags, heap);
|
||||
|
||||
mResourceFlags = gdata->getField14();
|
||||
}
|
||||
|
||||
void TriggerParam::init(sead::Heap* heap) {
|
||||
sortFlagPtrArray(mBoolFlags);
|
||||
sortFlagPtrArray(mS32Flags);
|
||||
sortFlagPtrArray(mF32Flags);
|
||||
sortFlagPtrArray(mStringFlags);
|
||||
sortFlagPtrArray(mString64Flags);
|
||||
sortFlagPtrArray(mString256Flags);
|
||||
sortFlagPtrArray(mVector2fFlags);
|
||||
sortFlagPtrArray(mVector3fFlags);
|
||||
sortFlagPtrArray(mVector4fFlags);
|
||||
allocCombinedFlagArrays(heap);
|
||||
updateBoolFlagCounts();
|
||||
mHeap = heap;
|
||||
}
|
||||
|
||||
void TriggerParam::allocCombinedFlagArrays(sead::Heap* heap) {
|
||||
#define ALLOC_COMBINED_ARRAY_(FLAGS, FLAG_ARRAYS, DEST) \
|
||||
{ \
|
||||
s32 size = FLAGS.size(); \
|
||||
for (s32 i = 0; i < FLAG_ARRAYS.size(); ++i) \
|
||||
size += FLAG_ARRAYS[i]->size(); \
|
||||
\
|
||||
DEST.allocBuffer(size, heap); \
|
||||
}
|
||||
|
||||
ALLOC_COMBINED_ARRAY_(mBoolFlags, mBoolArrayFlags, mCombinedBoolFlags);
|
||||
ALLOC_COMBINED_ARRAY_(mS32Flags, mS32ArrayFlags, mCombinedS32Flags);
|
||||
ALLOC_COMBINED_ARRAY_(mF32Flags, mF32ArrayFlags, mCombinedF32Flags);
|
||||
ALLOC_COMBINED_ARRAY_(mStringFlags, mStringArrayFlags, mCombinedStringFlags);
|
||||
ALLOC_COMBINED_ARRAY_(mString64Flags, mString64ArrayFlags, mCombinedString64Flags);
|
||||
ALLOC_COMBINED_ARRAY_(mString256Flags, mString256ArrayFlags, mCombinedString256Flags);
|
||||
ALLOC_COMBINED_ARRAY_(mVector2fFlags, mVector2fArrayFlags, mCombinedVector2fFlags);
|
||||
ALLOC_COMBINED_ARRAY_(mVector3fFlags, mVector3fArrayFlags, mCombinedVector3fFlags);
|
||||
ALLOC_COMBINED_ARRAY_(mVector4fFlags, mVector4fArrayFlags, mCombinedVector4fFlags);
|
||||
|
||||
#undef ALLOC_COMBINED_ARRAY_
|
||||
}
|
||||
|
||||
void TriggerParam::updateBoolFlagCounts() {
|
||||
for (s32 i = 0; i < mBoolFlags.size(); ++i) {
|
||||
const s32 category = mBoolFlags[i]->getCategory();
|
||||
if (category > 0)
|
||||
++mNumBoolFlagsPerCategory[category - 1];
|
||||
}
|
||||
|
||||
for (s32 array_i = 0; array_i < mBoolArrayFlags.size(); ++array_i) {
|
||||
for (s32 i = 0; i < mBoolArrayFlags[array_i]->size(); ++i) {
|
||||
const s32 category = (*mBoolArrayFlags[array_i])[i]->getCategory();
|
||||
if (category > 0)
|
||||
++mNumBoolFlagsPerCategory[category - 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TriggerParam::destroyHeap() {
|
||||
util::safeDeleteHeap(mHeap);
|
||||
}
|
||||
|
||||
void TriggerParam::allocBools(s32 size, sead::Heap* heap) {
|
||||
mBoolFlags.allocBuffer(size, heap);
|
||||
}
|
||||
|
||||
void TriggerParam::allocS32s(s32 size, sead::Heap* heap) {
|
||||
mS32Flags.allocBuffer(size, heap);
|
||||
}
|
||||
|
||||
void TriggerParam::initResetData(sead::Heap* heap) {
|
||||
s32 num_reset_entries = 0;
|
||||
|
||||
#define COUNT_FLAGS_(FLAGS) \
|
||||
do { \
|
||||
for (s32 i = 0; i < FLAGS.size(); ++i) { \
|
||||
if (FLAGS[i]->isResettable()) \
|
||||
++num_reset_entries; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define COUNT_FLAGS_ARRAY_(ARRAYS) \
|
||||
do { \
|
||||
for (s32 i = 0; i < ARRAYS.size(); ++i) { \
|
||||
if ((*ARRAYS[i])[0]->isResettable()) \
|
||||
++num_reset_entries; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
COUNT_FLAGS_(mBoolFlags);
|
||||
COUNT_FLAGS_(mS32Flags);
|
||||
COUNT_FLAGS_(mF32Flags);
|
||||
COUNT_FLAGS_(mStringFlags);
|
||||
COUNT_FLAGS_(mString64Flags);
|
||||
COUNT_FLAGS_(mString256Flags);
|
||||
COUNT_FLAGS_(mVector2fFlags);
|
||||
COUNT_FLAGS_(mVector3fFlags);
|
||||
COUNT_FLAGS_(mVector4fFlags);
|
||||
|
||||
COUNT_FLAGS_ARRAY_(mBoolArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mS32ArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mF32ArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mStringArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mString64ArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mString256ArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mVector2fArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mVector3fArrayFlags);
|
||||
COUNT_FLAGS_ARRAY_(mVector4fArrayFlags);
|
||||
|
||||
#undef COUNT_FLAGS_
|
||||
#undef COUNT_FLAGS_ARRAY_
|
||||
|
||||
if (num_reset_entries == 0)
|
||||
return;
|
||||
|
||||
mResetEntries.allocBufferAssert(num_reset_entries, heap);
|
||||
|
||||
s32 reset_entry_idx = 0;
|
||||
|
||||
#define ADD_ENTRIES_(TYPE, FLAGS) \
|
||||
do { \
|
||||
for (s32 i = 0; i < FLAGS.size(); ++i) { \
|
||||
if (!FLAGS[i]->isResettable()) \
|
||||
continue; \
|
||||
mResetEntries[reset_entry_idx].type = TYPE; \
|
||||
mResetEntries[reset_entry_idx].index = i; \
|
||||
mResetEntries[reset_entry_idx].reset_type = FLAGS[i]->getProperties().getResetType(); \
|
||||
++reset_entry_idx; \
|
||||
if (reset_entry_idx == num_reset_entries) \
|
||||
return; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define ADD_ENTRIES_ARRAY_(TYPE, ARRAYS) \
|
||||
do { \
|
||||
for (s32 i = 0; i < ARRAYS.size(); ++i) { \
|
||||
if (!(*ARRAYS[i])[0]->isResettable()) \
|
||||
continue; \
|
||||
\
|
||||
mResetEntries[reset_entry_idx].type = TYPE; \
|
||||
\
|
||||
/* ??? */ \
|
||||
if constexpr (TYPE == FlagType::String256Array) \
|
||||
mResetEntries[reset_entry_idx].index = s16(i); \
|
||||
else \
|
||||
mResetEntries[reset_entry_idx].index = i; \
|
||||
\
|
||||
mResetEntries[reset_entry_idx].reset_type = \
|
||||
(*ARRAYS[i])[0]->getProperties().getResetType(); \
|
||||
\
|
||||
++reset_entry_idx; \
|
||||
if (reset_entry_idx == num_reset_entries) \
|
||||
return; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
ADD_ENTRIES_(FlagType::Bool, mBoolFlags);
|
||||
ADD_ENTRIES_(FlagType::S32, mS32Flags);
|
||||
ADD_ENTRIES_(FlagType::F32, mF32Flags);
|
||||
ADD_ENTRIES_(FlagType::String, mStringFlags);
|
||||
ADD_ENTRIES_(FlagType::String64, mString64Flags);
|
||||
ADD_ENTRIES_(FlagType::String256, mString256Flags);
|
||||
ADD_ENTRIES_(FlagType::Vector2f, mVector2fFlags);
|
||||
ADD_ENTRIES_(FlagType::Vector3f, mVector3fFlags);
|
||||
ADD_ENTRIES_(FlagType::Vector4f, mVector4fFlags);
|
||||
|
||||
ADD_ENTRIES_ARRAY_(FlagType::BoolArray, mBoolArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::S32Array, mS32ArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::F32Array, mF32ArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::StringArray, mStringArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::String64Array, mString64ArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::String256Array, mString256ArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::Vector2fArray, mVector2fArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::Vector3fArray, mVector3fArrayFlags);
|
||||
ADD_ENTRIES_ARRAY_(FlagType::Vector4fArray, mVector4fArrayFlags);
|
||||
|
||||
#undef ADD_ENTRIES_
|
||||
#undef ADD_ENTRIES_ARRAY_
|
||||
}
|
||||
|
||||
void TriggerParam::initRevivalRandomBools(sead::Heap* heap) {
|
||||
s32 count = 0;
|
||||
for (s32 i = 0; i < mBoolFlags.size(); ++i) {
|
||||
if (static_cast<FlagBool*>(mBoolFlags[i])->getRandomResetData())
|
||||
++count;
|
||||
}
|
||||
|
||||
if (count == 0)
|
||||
return;
|
||||
|
||||
mRevivalRandomBools.allocBuffer(count, heap);
|
||||
for (s32 i = 0; i < mBoolFlags.size(); ++i) {
|
||||
if (static_cast<FlagBool*>(mBoolFlags[i])->getRandomResetData())
|
||||
mRevivalRandomBools.pushBack(static_cast<FlagBool*>(mBoolFlags[i]));
|
||||
}
|
||||
}
|
||||
|
||||
void TriggerParam::copyAllFlags(const TriggerParam& src, sead::Heap* heap, bool init_reset_data) {
|
||||
mResourceFlags = src.mResourceFlags;
|
||||
|
||||
s32 num_flags = 0;
|
||||
|
||||
#define COPY_(MEMBER, T) \
|
||||
do { \
|
||||
const auto size = src.MEMBER.size(); \
|
||||
if (size > 0) { \
|
||||
MEMBER.allocBuffer(size, heap); \
|
||||
makeFlagProxies<T>(MEMBER, src.MEMBER, size, heap, false); \
|
||||
num_flags += size; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
COPY_(mBoolFlags, bool);
|
||||
COPY_(mS32Flags, s32);
|
||||
COPY_(mF32Flags, f32);
|
||||
COPY_(mStringFlags, sead::FixedSafeString<32>);
|
||||
COPY_(mString64Flags, sead::FixedSafeString<64>);
|
||||
COPY_(mString256Flags, sead::FixedSafeString<256>);
|
||||
COPY_(mVector2fFlags, sead::Vector2f);
|
||||
COPY_(mVector3fFlags, sead::Vector3f);
|
||||
COPY_(mVector4fFlags, sead::Vector4f);
|
||||
|
||||
#undef COPY_
|
||||
|
||||
#define COPY_ARRAY_(MEMBER, T) \
|
||||
do { \
|
||||
const auto size = src.MEMBER.size(); \
|
||||
if (size > 0) { \
|
||||
MEMBER.allocBuffer(size, heap); \
|
||||
for (s32 i = 0; i < size; ++i) { \
|
||||
const auto array_size = src.MEMBER[i]->size(); \
|
||||
if (array_size > 0) { \
|
||||
MEMBER.pushBack(new (heap) sead::PtrArray<FlagBase>); \
|
||||
MEMBER[i]->allocBuffer(std::max(1, array_size), heap); \
|
||||
makeFlagProxies<T>(*MEMBER[i], *src.MEMBER[i], array_size, heap, false); \
|
||||
num_flags += size; \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
COPY_ARRAY_(mBoolArrayFlags, bool);
|
||||
COPY_ARRAY_(mS32ArrayFlags, s32);
|
||||
COPY_ARRAY_(mF32ArrayFlags, f32);
|
||||
COPY_ARRAY_(mStringArrayFlags, sead::FixedSafeString<32>);
|
||||
COPY_ARRAY_(mString64ArrayFlags, sead::FixedSafeString<64>);
|
||||
COPY_ARRAY_(mString256ArrayFlags, sead::FixedSafeString<256>);
|
||||
COPY_ARRAY_(mVector2fArrayFlags, sead::Vector2f);
|
||||
COPY_ARRAY_(mVector3fArrayFlags, sead::Vector3f);
|
||||
COPY_ARRAY_(mVector4fArrayFlags, sead::Vector4f);
|
||||
|
||||
#undef COPY_
|
||||
#undef COPY_ARRAY_
|
||||
|
||||
if (init_reset_data) {
|
||||
for (auto& array : *mUnkArray.data())
|
||||
array.allocBufferAssert(num_flags, heap);
|
||||
initResetData(heap);
|
||||
initRevivalRandomBools(heap);
|
||||
}
|
||||
|
||||
mHeap = heap;
|
||||
}
|
||||
|
||||
void TriggerParam::copyPermanentFlags(const TriggerParam& src, sead::Heap* heap) {
|
||||
#define COPY_(MEMBER, T) \
|
||||
do { \
|
||||
const auto size = src.MEMBER.size(); \
|
||||
if (size > 0) { \
|
||||
s32 num_permanent_flags = 0; \
|
||||
for (s32 i = 0; i < size; ++i) { \
|
||||
if (src.MEMBER[i]->isPermanent()) \
|
||||
++num_permanent_flags; \
|
||||
} \
|
||||
MEMBER.allocBuffer(std::max(1, num_permanent_flags), heap); \
|
||||
makeFlagProxies<T>(MEMBER, src.MEMBER, size, heap, true); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
COPY_(mBoolFlags, bool);
|
||||
COPY_(mS32Flags, s32);
|
||||
COPY_(mF32Flags, f32);
|
||||
COPY_(mStringFlags, sead::FixedSafeString<32>);
|
||||
COPY_(mString64Flags, sead::FixedSafeString<64>);
|
||||
COPY_(mString256Flags, sead::FixedSafeString<256>);
|
||||
COPY_(mVector2fFlags, sead::Vector2f);
|
||||
COPY_(mVector3fFlags, sead::Vector3f);
|
||||
COPY_(mVector4fFlags, sead::Vector4f);
|
||||
|
||||
#undef COPY_
|
||||
|
||||
#define COPY_ARRAY_(MEMBER, T) \
|
||||
do { \
|
||||
const auto size = src.MEMBER.size(); \
|
||||
if (size > 0) { \
|
||||
MEMBER.allocBuffer(size, heap); \
|
||||
for (s32 i = 0; i < size; ++i) { \
|
||||
const auto array_size = src.MEMBER[i]->size(); \
|
||||
if (array_size > 0) { \
|
||||
auto* array = new (heap) sead::PtrArray<FlagBase>; \
|
||||
MEMBER.pushBack(array); \
|
||||
MEMBER[i]->allocBuffer(std::max(1, array_size), heap); \
|
||||
makeFlagProxies<T>(*MEMBER[i], *src.MEMBER[i], array_size, heap, true); \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
COPY_ARRAY_(mBoolArrayFlags, bool);
|
||||
COPY_ARRAY_(mS32ArrayFlags, s32);
|
||||
COPY_ARRAY_(mF32ArrayFlags, f32);
|
||||
COPY_ARRAY_(mStringArrayFlags, sead::FixedSafeString<32>);
|
||||
COPY_ARRAY_(mString64ArrayFlags, sead::FixedSafeString<64>);
|
||||
COPY_ARRAY_(mString256ArrayFlags, sead::FixedSafeString<256>);
|
||||
COPY_ARRAY_(mVector2fArrayFlags, sead::Vector2f);
|
||||
COPY_ARRAY_(mVector3fArrayFlags, sead::Vector3f);
|
||||
COPY_ARRAY_(mVector4fArrayFlags, sead::Vector4f);
|
||||
|
||||
#undef COPY_
|
||||
#undef COPY_ARRAY_
|
||||
|
||||
mHeap = heap;
|
||||
}
|
||||
|
||||
FlagType TriggerParam::getFlagType(const sead::SafeString& name) const {
|
||||
if (getBoolIdx(name) != -1)
|
||||
return FlagType::Bool;
|
||||
if (getBoolArrayIdx(name) != -1)
|
||||
return FlagType::BoolArray;
|
||||
|
||||
if (getS32Idx(name) != -1)
|
||||
return FlagType::S32;
|
||||
if (getS32ArrayIdx(name) != -1)
|
||||
return FlagType::S32Array;
|
||||
|
||||
if (getStrIdx(name) != -1)
|
||||
return FlagType::String;
|
||||
if (getStrArrayIdx(name) != -1)
|
||||
return FlagType::StringArray;
|
||||
|
||||
if (getF32Idx(name) != -1)
|
||||
return FlagType::F32;
|
||||
if (getF32ArrayIdx(name) != -1)
|
||||
return FlagType::F32Array;
|
||||
|
||||
if (getVec3fIdx(name) != -1)
|
||||
return FlagType::Vector3f;
|
||||
if (getVec3fArrayIdx(name) != -1)
|
||||
return FlagType::Vector3fArray;
|
||||
|
||||
if (getStr64Idx(name) != -1)
|
||||
return FlagType::String64;
|
||||
|
||||
if (getStr256ArrayIdx(name) != -1)
|
||||
return FlagType::String256Array;
|
||||
if (getStr256Idx(name) != -1)
|
||||
return FlagType::String256;
|
||||
|
||||
if (getStr64ArrayIdx(name) != -1)
|
||||
return FlagType::String64Array;
|
||||
|
||||
if (getVec2fIdx(name) != -1)
|
||||
return FlagType::Vector2f;
|
||||
if (getVec2fArrayIdx(name) != -1)
|
||||
return FlagType::Vector2fArray;
|
||||
|
||||
if (getVec4fIdx(name) != -1)
|
||||
return FlagType::Vector4f;
|
||||
if (getVec4fArrayIdx(name) != -1)
|
||||
return FlagType::Vector4fArray;
|
||||
|
||||
return FlagType::Invalid;
|
||||
}
|
||||
|
||||
bool TriggerParam::getBool(bool* value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mBoolFlags, value, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32(s32* value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mS32Flags, value, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getF32(f32* value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mF32Flags, value, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr(const char** value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue<const char*, sead::FixedSafeString<32>>(mStringFlags, value, index,
|
||||
check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64(const char** value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue<const char*, sead::FixedSafeString<64>>(mString64Flags, value, index,
|
||||
check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr256(const char** value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue<const char*, sead::FixedSafeString<256>>(mString256Flags, value, index,
|
||||
check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec2f(sead::Vector2f* value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mVector2fFlags, value, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3f(sead::Vector3f* value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mVector3fFlags, value, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec4f(sead::Vector4f* value, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mVector4fFlags, value, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getBool(bool* value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getBool(value, getBoolIdx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getBool2(bool* value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getBool(value, getBoolIdx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32(s32* value, const sead::SafeString& name, bool check_permissions) const {
|
||||
return getS32(value, getS32Idx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getF32(f32* value, const sead::SafeString& name, bool check_permissions) const {
|
||||
return getF32(value, getF32Idx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr(const char** value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getStr(value, getStrIdx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64(const char** value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getStr64(value, getStr64Idx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr256(const char** value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getStr256(value, getStr256Idx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec2f(sead::Vector2f* value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getVec2f(value, getVec2fIdx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3f(sead::Vector3f* value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getVec3f(value, getVec3fIdx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec4f(sead::Vector4f* value, const sead::SafeString& name,
|
||||
bool check_permissions) const {
|
||||
return getVec4f(value, getVec4fIdx(name), check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getBool(bool* value, s32 array_index, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mBoolArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32(s32* value, s32 array_index, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mS32ArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getF32(f32* value, s32 array_index, s32 index, bool check_permissions) const {
|
||||
return getFlagValue(mF32ArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr(const char** value, s32 array_index, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getFlagValue<const char*, sead::FixedSafeString<32>>(
|
||||
mStringArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64(const char** value, s32 array_index, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getFlagValue<const char*, sead::FixedSafeString<64>>(
|
||||
mString64ArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr256(const char** value, s32 array_index, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getFlagValue<const char*, sead::FixedSafeString<256>>(
|
||||
mString256ArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec2f(sead::Vector2f* value, s32 array_index, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getFlagValue(mVector2fArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3f(sead::Vector3f* value, s32 array_index, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getFlagValue(mVector3fArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec4f(sead::Vector4f* value, s32 array_index, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getFlagValue(mVector4fArrayFlags, value, array_index, index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getBool(bool* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getBool(value, getBoolArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32(s32* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getS32(value, getS32ArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getF32(f32* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getF32(value, getF32ArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr(const char** value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getStr(value, getStrArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64(const char** value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getStr64(value, getStr64ArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr256(const char** value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getStr256(value, getStr256ArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec2f(sead::Vector2f* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getVec2f(value, getVec2fArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3f(sead::Vector3f* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getVec3f(value, getVec3fArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec4f(sead::Vector4f* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const {
|
||||
return getVec4f(value, getVec4fArrayIdx(name), index, check_permissions);
|
||||
}
|
||||
|
||||
bool TriggerParam::getBoolArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mBoolArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32ArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mS32ArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getF32ArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mF32ArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStrArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mStringArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64ArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mString64ArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr256ArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mString256ArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec2fArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mVector2fArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3fArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mVector3fArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec4fArraySize(s32* size, s32 index) const {
|
||||
return getFlagArraySize(mVector4fArrayFlags, index, size);
|
||||
}
|
||||
|
||||
bool TriggerParam::getBoolArraySizeByHash(s32* size, u32 name) const {
|
||||
return getBoolArraySize(size, getBoolArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32ArraySizeByHash(s32* size, u32 name) const {
|
||||
return getS32ArraySize(size, getS32ArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getF32ArraySizeByHash(s32* size, u32 name) const {
|
||||
return getF32ArraySize(size, getF32ArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getStrArraySizeByHash(s32* size, u32 name) const {
|
||||
return getStrArraySize(size, getStrArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64ArraySizeByHash(s32* size, u32 name) const {
|
||||
return getStr64ArraySize(size, getStr64ArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr256ArraySizeByHash(s32* size, u32 name) const {
|
||||
return getStr256ArraySize(size, getStr256ArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec2fArraySizeByHash(s32* size, u32 name) const {
|
||||
return getVec2fArraySize(size, getVec2fArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3fArraySizeByHash(s32* size, u32 name) const {
|
||||
return getVec3fArraySize(size, getVec3fArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec4fArraySizeByHash(s32* size, u32 name) const {
|
||||
return getVec4fArraySize(size, getVec4fArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getS32ArraySize(s32* size, const sead::SafeString& name) const {
|
||||
return getS32ArraySize(size, getS32ArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getStr64ArraySize(s32* size, const sead::SafeString& name) const {
|
||||
return getStr64ArraySize(size, getStr64ArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getVec3fArraySize(s32* size, const sead::SafeString& name) const {
|
||||
return getVec3fArraySize(size, getVec3fArrayIdx(name));
|
||||
}
|
||||
|
||||
bool TriggerParam::getMinValueForS32(s32* min, const sead::SafeString& name) const {
|
||||
const auto* flag = getFlag<s32>(mS32Flags, name);
|
||||
if (!flag)
|
||||
return false;
|
||||
*min = flag->getConfig().min_value;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TriggerParam::getMaxValueForS32(s32* max, const sead::SafeString& name) const {
|
||||
const auto* flag = getFlag<s32>(mS32Flags, name);
|
||||
if (!flag)
|
||||
return false;
|
||||
*max = flag->getConfig().max_value;
|
||||
return true;
|
||||
}
|
||||
|
||||
s32 TriggerParam::getBoolIdx(u32 name) const {
|
||||
return getFlagIndex(mBoolFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getS32Idx(u32 name) const {
|
||||
return getFlagIndex(mS32Flags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getF32Idx(u32 name) const {
|
||||
return getFlagIndex(mF32Flags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getStrIdx(u32 name) const {
|
||||
return getFlagIndex(mStringFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getStr64Idx(u32 name) const {
|
||||
return getFlagIndex(mString64Flags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getStr256Idx(u32 name) const {
|
||||
return getFlagIndex(mString256Flags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getVec2fIdx(u32 name) const {
|
||||
return getFlagIndex(mVector2fFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getVec3fIdx(u32 name) const {
|
||||
return getFlagIndex(mVector3fFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getVec4fIdx(u32 name) const {
|
||||
return getFlagIndex(mVector4fFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getBoolArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mBoolArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getS32ArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mS32ArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getF32ArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mF32ArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getStrArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mStringArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getStr64ArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mString64ArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getStr256ArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mString256ArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getVec2fArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mVector2fArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getVec3fArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mVector3fArrayFlags, name);
|
||||
}
|
||||
|
||||
s32 TriggerParam::getVec4fArrayIdx(u32 name) const {
|
||||
return getFlagIndex(mVector4fArrayFlags, name);
|
||||
}
|
||||
|
||||
} // namespace ksys::gdt
|
||||
|
||||
@@ -1,7 +1,9 @@
|
||||
#pragma once
|
||||
|
||||
#include <basis/seadTypes.h>
|
||||
#include <codec/seadHashCRC32.h>
|
||||
#include <container/seadBuffer.h>
|
||||
#include <container/seadObjArray.h>
|
||||
#include <container/seadPtrArray.h>
|
||||
#include <container/seadSafeArray.h>
|
||||
#include <prim/seadStorageFor.h>
|
||||
@@ -9,6 +11,10 @@
|
||||
#include "KingSystem/GameData/gdtFlag.h"
|
||||
#include "KingSystem/Utils/Types.h"
|
||||
|
||||
namespace ksys::res {
|
||||
class GameData;
|
||||
}
|
||||
|
||||
namespace ksys::gdt {
|
||||
|
||||
class TriggerParam {
|
||||
@@ -22,69 +28,247 @@ public:
|
||||
|
||||
TriggerParam();
|
||||
|
||||
void copyFromGameDataRes(res::GameData* gdata, sead::Heap* heap);
|
||||
void init(sead::Heap* heap);
|
||||
void destroyHeap();
|
||||
void allocBools(s32 size, sead::Heap* heap);
|
||||
void allocS32s(s32 size, sead::Heap* heap);
|
||||
void copyAllFlags(const TriggerParam& src, sead::Heap* heap, bool init_reset_data);
|
||||
void copyPermanentFlags(const TriggerParam& src, sead::Heap* heap);
|
||||
|
||||
FlagType getFlagType(const sead::SafeString& name) const;
|
||||
|
||||
// region Value getters (by hash)
|
||||
|
||||
bool getBool(bool* value, s32 index, bool check_permissions) const;
|
||||
bool getS32(s32* value, s32 index, bool check_permissions) const;
|
||||
bool getF32(f32* value, s32 index, bool check_permissions) const;
|
||||
bool getStr(const char** value, s32 index, bool check_permissions) const;
|
||||
bool getStr64(const char** value, s32 index, bool check_permissions) const;
|
||||
bool getStr256(const char** value, s32 index, bool check_permissions) const;
|
||||
bool getVec2f(sead::Vector2f* value, s32 index, bool check_permissions) const;
|
||||
bool getVec3f(sead::Vector3f* value, s32 index, bool check_permissions) const;
|
||||
bool getVec4f(sead::Vector4f* value, s32 index, bool check_permissions) const;
|
||||
|
||||
bool getBool(bool* value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getS32(s32* value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getF32(f32* value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getStr(const char** value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getStr64(const char** value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getStr256(const char** value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getVec2f(sead::Vector2f* value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getVec3f(sead::Vector3f* value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
bool getVec4f(sead::Vector4f* value, s32 array_index, s32 index, bool check_permissions) const;
|
||||
|
||||
// endregion
|
||||
|
||||
// region Value getters (by name)
|
||||
|
||||
bool getBool(bool* value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getBool2(bool* value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getS32(s32* value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getF32(f32* value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getStr(const char** value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getStr64(const char** value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getStr256(const char** value, const sead::SafeString& name, bool check_permissions) const;
|
||||
bool getVec2f(sead::Vector2f* value, const sead::SafeString& name,
|
||||
bool check_permissions) const;
|
||||
bool getVec3f(sead::Vector3f* value, const sead::SafeString& name,
|
||||
bool check_permissions) const;
|
||||
bool getVec4f(sead::Vector4f* value, const sead::SafeString& name,
|
||||
bool check_permissions) const;
|
||||
|
||||
bool getBool(bool* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
bool getS32(s32* value, const sead::SafeString& name, s32 index, bool check_permissions) const;
|
||||
bool getF32(f32* value, const sead::SafeString& name, s32 index, bool check_permissions) const;
|
||||
bool getStr(const char** value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
bool getStr64(const char** value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
bool getStr256(const char** value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
bool getVec2f(sead::Vector2f* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
bool getVec3f(sead::Vector3f* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
bool getVec4f(sead::Vector4f* value, const sead::SafeString& name, s32 index,
|
||||
bool check_permissions) const;
|
||||
|
||||
// endregion
|
||||
|
||||
// region Index getters (by hash)
|
||||
|
||||
s32 getBoolIdx(u32 name) const;
|
||||
s32 getS32Idx(u32 name) const;
|
||||
s32 getF32Idx(u32 name) const;
|
||||
s32 getStrIdx(u32 name) const;
|
||||
s32 getStr64Idx(u32 name) const;
|
||||
s32 getStr256Idx(u32 name) const;
|
||||
s32 getVec2fIdx(u32 name) const;
|
||||
s32 getVec3fIdx(u32 name) const;
|
||||
s32 getVec4fIdx(u32 name) const;
|
||||
s32 getBoolArrayIdx(u32 name) const;
|
||||
s32 getS32ArrayIdx(u32 name) const;
|
||||
s32 getF32ArrayIdx(u32 name) const;
|
||||
s32 getStrArrayIdx(u32 name) const;
|
||||
s32 getStr64ArrayIdx(u32 name) const;
|
||||
s32 getStr256ArrayIdx(u32 name) const;
|
||||
s32 getVec2fArrayIdx(u32 name) const;
|
||||
s32 getVec3fArrayIdx(u32 name) const;
|
||||
s32 getVec4fArrayIdx(u32 name) const;
|
||||
|
||||
// endregion
|
||||
|
||||
// region Index getters (by name)
|
||||
|
||||
s32 getBoolIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getBoolIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getS32Idx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getS32Idx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getF32Idx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getF32Idx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getStrIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getStrIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getStr64Idx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getStr64Idx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getStr256Idx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getStr256Idx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getVec2fIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getVec2fIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getVec3fIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getVec3fIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getVec4fIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getVec4fIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getBoolArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getBoolArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getS32ArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getS32ArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getF32ArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getF32ArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getStrArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getStrArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getStr64ArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getStr64ArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getStr256ArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getStr256ArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getVec2fArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getVec2fArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getVec3fArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getVec3fArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
s32 getVec4fArrayIdx(const sead::SafeString& name) const {
|
||||
return name.isEmpty() ? -1 : getVec4fArrayIdx(sead::HashCRC32::calcStringHash(name));
|
||||
}
|
||||
|
||||
// endregion
|
||||
|
||||
// region Array size getters
|
||||
|
||||
bool getBoolArraySize(s32* size, s32 index) const;
|
||||
bool getS32ArraySize(s32* size, s32 index) const;
|
||||
bool getF32ArraySize(s32* size, s32 index) const;
|
||||
bool getStrArraySize(s32* size, s32 index) const;
|
||||
bool getStr64ArraySize(s32* size, s32 index) const;
|
||||
bool getStr256ArraySize(s32* size, s32 index) const;
|
||||
bool getVec2fArraySize(s32* size, s32 index) const;
|
||||
bool getVec3fArraySize(s32* size, s32 index) const;
|
||||
bool getVec4fArraySize(s32* size, s32 index) const;
|
||||
|
||||
bool getBoolArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getS32ArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getF32ArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getStrArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getStr64ArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getStr256ArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getVec2fArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getVec3fArraySizeByHash(s32* size, u32 name) const;
|
||||
bool getVec4fArraySizeByHash(s32* size, u32 name) const;
|
||||
|
||||
bool getS32ArraySize(s32* size, const sead::SafeString& name) const;
|
||||
bool getStr64ArraySize(s32* size, const sead::SafeString& name) const;
|
||||
bool getVec3fArraySize(s32* size, const sead::SafeString& name) const;
|
||||
|
||||
// endregion
|
||||
|
||||
bool getMinValueForS32(s32* min, const sead::SafeString& name) const;
|
||||
bool getMaxValueForS32(s32* max, const sead::SafeString& name) const;
|
||||
|
||||
private:
|
||||
enum class Flag : u8 {
|
||||
enum class BitFlag : u8 {
|
||||
|
||||
};
|
||||
|
||||
sead::TypedBitFlag<Flag>& getFlags() { return *mFlags.data(); }
|
||||
const sead::TypedBitFlag<Flag>& getFlags() const { return *mFlags.data(); }
|
||||
void allocCombinedFlagArrays(sead::Heap* heap);
|
||||
void updateBoolFlagCounts();
|
||||
void initResetData(sead::Heap* heap);
|
||||
void initRevivalRandomBools(sead::Heap* heap);
|
||||
|
||||
sead::TypedBitFlag<BitFlag>& getBitFlags() { return *mBitFlags.data(); }
|
||||
const sead::TypedBitFlag<BitFlag>& getBitFlags() const { return *mBitFlags.data(); }
|
||||
sead::SafeArray<sead::CriticalSection, 3>& getCriticalSections() {
|
||||
return *mCriticalSections.data();
|
||||
}
|
||||
|
||||
u32 mResourceFlags = 0;
|
||||
|
||||
sead::PtrArray<FlagBool> mBoolFlags;
|
||||
sead::PtrArray<FlagS32> mS32Flags;
|
||||
sead::PtrArray<FlagF32> mF32Flags;
|
||||
sead::PtrArray<FlagString> mStringFlags;
|
||||
sead::PtrArray<FlagString64> mString64Flags;
|
||||
sead::PtrArray<FlagString256> mString256Flags;
|
||||
sead::PtrArray<FlagVector2f> mVector2fFlags;
|
||||
sead::PtrArray<FlagVector3f> mVector3fFlags;
|
||||
sead::PtrArray<FlagVector4f> mVector4fFlags;
|
||||
sead::PtrArray<FlagBase> mBoolFlags;
|
||||
sead::PtrArray<FlagBase> mS32Flags;
|
||||
sead::PtrArray<FlagBase> mF32Flags;
|
||||
sead::PtrArray<FlagBase> mStringFlags;
|
||||
sead::PtrArray<FlagBase> mString64Flags;
|
||||
sead::PtrArray<FlagBase> mString256Flags;
|
||||
sead::PtrArray<FlagBase> mVector2fFlags;
|
||||
sead::PtrArray<FlagBase> mVector3fFlags;
|
||||
sead::PtrArray<FlagBase> mVector4fFlags;
|
||||
|
||||
sead::PtrArray<FlagBoolArray> mBoolArrayFlags;
|
||||
sead::PtrArray<FlagS32Array> mS32ArrayFlags;
|
||||
sead::PtrArray<FlagF32Array> mF32ArrayFlags;
|
||||
sead::PtrArray<FlagStringArray> mStringArrayFlags;
|
||||
sead::PtrArray<FlagString64Array> mString64ArrayFlags;
|
||||
sead::PtrArray<FlagString256Array> mString256ArrayFlags;
|
||||
sead::PtrArray<FlagVector2fArray> mVector2fArrayFlags;
|
||||
sead::PtrArray<FlagVector3fArray> mVector3fArrayFlags;
|
||||
sead::PtrArray<FlagVector4fArray> mVector4fArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mBoolArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mS32ArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mF32ArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mStringArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mString64ArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mString256ArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mVector2fArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mVector3fArrayFlags;
|
||||
sead::PtrArray<sead::PtrArray<FlagBase>> mVector4fArrayFlags;
|
||||
|
||||
sead::StorageFor<sead::SafeArray<sead::Buffer<ResetEntry>, 3>> mUnkArray{};
|
||||
|
||||
sead::ObjArray<FlagBase> mCombinedBoolFlags;
|
||||
sead::ObjArray<FlagBase> mCombinedS32Flags;
|
||||
sead::ObjArray<FlagBase> mCombinedF32Flags;
|
||||
sead::ObjArray<FlagBase> mCombinedStringFlags;
|
||||
sead::ObjArray<FlagBase> mCombinedString64Flags;
|
||||
sead::ObjArray<FlagBase> mCombinedString256Flags;
|
||||
sead::ObjArray<FlagBase> mCombinedVector2fFlags;
|
||||
sead::ObjArray<FlagBase> mCombinedVector3fFlags;
|
||||
sead::ObjArray<FlagBase> mCombinedVector4fFlags;
|
||||
|
||||
// FIXME
|
||||
sead::PtrArray<FlagBool> mUnkArray0;
|
||||
sead::PtrArray<FlagBool> mUnkArray1;
|
||||
sead::PtrArray<FlagBool> mUnkArray2;
|
||||
sead::PtrArray<FlagBool> mUnkArray3;
|
||||
sead::PtrArray<FlagBool> mUnkArray4;
|
||||
sead::PtrArray<FlagBool> mUnkArray5;
|
||||
sead::PtrArray<FlagBool> mUnkArray6;
|
||||
sead::PtrArray<FlagBool> mUnkArray7;
|
||||
sead::PtrArray<FlagBool> mUnkArray8;
|
||||
sead::PtrArray<FlagBool> mUnkArray9;
|
||||
sead::PtrArray<FlagBool> mUnkArray10;
|
||||
sead::PtrArray<FlagBool> mUnkArray11;
|
||||
sead::PtrArray<FlagBool> mUnkArray12;
|
||||
sead::PtrArray<FlagBool> mUnkArray13;
|
||||
sead::PtrArray<FlagBool> mUnkArray14;
|
||||
sead::PtrArray<FlagBool> mUnkArray15;
|
||||
sead::PtrArray<FlagBool> mUnkArray16;
|
||||
sead::PtrArray<FlagBool> mUnkArray17;
|
||||
sead::PtrArray<FlagBool> mUnkArray18;
|
||||
sead::PtrArray<FlagBool> mUnkArray19;
|
||||
sead::PtrArray<FlagBool> mUnkArray20;
|
||||
sead::Buffer<ResetEntry> mResetEntries;
|
||||
sead::PtrArray<FlagBool> mRevivalRandomBools;
|
||||
|
||||
sead::Heap* mHeap = nullptr;
|
||||
|
||||
sead::SafeArray<s32, 33> mCounts;
|
||||
sead::SafeArray<s32, 18> mCounts;
|
||||
sead::SafeArray<s32, 15> mNumBoolFlagsPerCategory;
|
||||
sead::StorageFor<sead::SafeArray<sead::CriticalSection, 3>> mCriticalSections{};
|
||||
sead::StorageFor<sead::TypedBitFlag<Flag>> mFlags;
|
||||
sead::StorageFor<sead::TypedBitFlag<BitFlag>> mBitFlags;
|
||||
};
|
||||
KSYS_CHECK_SIZE_NX150(TriggerParam, 0x3f0);
|
||||
|
||||
|
||||
@@ -23,6 +23,27 @@ public:
|
||||
|
||||
s32 getField14() const { return _14; }
|
||||
|
||||
sead::Buffer<gdt::FlagBool>& getBoolFlags() { return mBoolFlags; }
|
||||
sead::Buffer<gdt::FlagS32>& getS32Flags() { return mS32Flags; }
|
||||
sead::Buffer<gdt::FlagF32>& getF32Flags() { return mF32Flags; }
|
||||
sead::Buffer<gdt::FlagString>& getStringFlags() { return mStringFlags; }
|
||||
sead::Buffer<gdt::FlagString64>& getString64Flags() { return mString64Flags; }
|
||||
sead::Buffer<gdt::FlagString256>& getString256Flags() { return mString256Flags; }
|
||||
sead::Buffer<gdt::FlagVector2f>& getVector2fFlags() { return mVector2fFlags; }
|
||||
sead::Buffer<gdt::FlagVector3f>& getVector3fFlags() { return mVector3fFlags; }
|
||||
sead::Buffer<gdt::FlagVector4f>& getVector4fFlags() { return mVector4fFlags; }
|
||||
sead::PtrArray<gdt::FlagBoolArray>& getBoolArrayFlags() { return mBoolArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagS32Array>& getS32ArrayFlags() { return mS32ArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagF32Array>& getF32ArrayFlags() { return mF32ArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagStringArray>& getStringArrayFlags() { return mStringArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagString64Array>& getString64ArrayFlags() { return mString64ArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagString256Array>& getString256ArrayFlags() {
|
||||
return mString256ArrayFlags;
|
||||
}
|
||||
sead::PtrArray<gdt::FlagVector2fArray>& getVector2fArrayFlags() { return mVector2fArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagVector3fArray>& getVector3fArrayFlags() { return mVector3fArrayFlags; }
|
||||
sead::PtrArray<gdt::FlagVector4fArray>& getVector4fArrayFlags() { return mVector4fArrayFlags; }
|
||||
|
||||
const sead::Buffer<gdt::FlagBool>& getBoolFlags() const { return mBoolFlags; }
|
||||
const sead::Buffer<gdt::FlagS32>& getS32Flags() const { return mS32Flags; }
|
||||
const sead::Buffer<gdt::FlagF32>& getF32Flags() const { return mF32Flags; }
|
||||
|
||||
@@ -26,6 +26,8 @@ public:
|
||||
|
||||
void calc();
|
||||
|
||||
void reportDebug(const sead::SafeString& message, const sead::SafeString& data);
|
||||
|
||||
ProductReporter* getReporter() const { return mReporter; }
|
||||
|
||||
bool get30() const { return _30; }
|
||||
|
||||
@@ -35,5 +35,6 @@ target_sources(uking PRIVATE
|
||||
ParamIO.h
|
||||
SafeDelete.h
|
||||
StrTreeMap.h
|
||||
TypeTraits.h
|
||||
Types.h
|
||||
)
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
#pragma once
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
namespace ksys {
|
||||
|
||||
template <class T, class...>
|
||||
struct IsAnyOfType : std::false_type {};
|
||||
template <class T, class Head, class... Tail>
|
||||
struct IsAnyOfType<T, Head, Tail...>
|
||||
: std::conditional_t<std::is_same_v<T, Head>, std::true_type, IsAnyOfType<T, Tail...>> {};
|
||||
|
||||
} // namespace ksys
|
||||
Reference in New Issue
Block a user