mirror/OpenMW
1
0
Fork 0
mirror of https://gitlab.com/OpenMW/openmw.git synced 2025-01-26 18:35:20 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'refactor_esm4' into 'master'

Browse Source 
Refactor components/esm4 to make it easier to load records to ESMStore

See merge request OpenMW/openmw!3301
This commit is contained in:
psi29a 2023-08-06 16:13:07 +00:00
commit ba4298f36d
189 changed files with 934 additions and 1039 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
apps/esmtool/tes4.cpp
View File

@ -9,6 +9,7 @@
#include <components/debug/writeflags.hpp>
#include <components/esm/esmcommon.hpp>
#include <components/esm/refid.hpp>
#include <components/esm/typetraits.hpp>
#include <components/esm4/reader.hpp>
#include <components/esm4/readerutils.hpp>
@ -145,19 +146,15 @@ namespace EsmTool
return;
std::cout << "\n Record: " << ESM::NAME(reader.hdr().record.typeId).toStringView();
if constexpr (ESM4::hasFormId<T>)
std::cout << "\n FormId: 0x" << ESM4::formIdToString(value.mFormId);
if constexpr (ESM::hasId<T>)
{
if constexpr (std::is_same_v<decltype(value.mId), ESM4::FormId>)
std::cout << "\n FormId: 0x" << ESM4::formIdToString(value.mId);
if constexpr (std::is_same_v<decltype(value.mId), ESM::FormId>)
std::cout << "\n " << ESM::RefId(value.mId);
else
std::cout << "\n Id: " << value.mId;
}
if constexpr (ESM4::hasFlags<T>)
std::cout << "\n Record flags: " << recordFlags(value.mFlags);
if constexpr (ESM4::hasParentFormId<T>)
std::cout << "\n ParentFormId: 0x" << ESM4::formIdToString(value.mParentFormId);
if constexpr (ESM4::hasParent<T>)
std::cout << "\n Parent: " << value.mParent;
if constexpr (ESM4::hasEditorId<T>)

18
apps/openmw/mwclass/classes.cpp
View File

@ -1,6 +1,22 @@
#include "classes.hpp"
#include <components/esm/records.hpp>
#include <components/esm4/loadacti.hpp>
#include <components/esm4/loadalch.hpp>
#include <components/esm4/loadammo.hpp>
#include <components/esm4/loadarmo.hpp>
#include <components/esm4/loadbook.hpp>
#include <components/esm4/loadclot.hpp>
#include <components/esm4/loadcont.hpp>
#include <components/esm4/loadcrea.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadfurn.hpp>
#include <components/esm4/loadingr.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadmisc.hpp>
#include <components/esm4/loadnpc.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadtree.hpp>
#include <components/esm4/loadweap.hpp>
#include "activator.hpp"
#include "apparatus.hpp"

38
apps/openmw/mwlua/cellbindings.cpp
View File

@ -1,7 +1,43 @@
#include "cellbindings.hpp"
#include <components/esm/esmbridge.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadappa.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadlock.hpp>
#include <components/esm3/loadmisc.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadprob.hpp>
#include <components/esm3/loadrepa.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/loadweap.hpp>
#include <components/esm4/loadacti.hpp>
#include <components/esm4/loadalch.hpp>
#include <components/esm4/loadammo.hpp>
#include <components/esm4/loadarmo.hpp>
#include <components/esm4/loadbook.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loadclot.hpp>
#include <components/esm4/loadcont.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadfurn.hpp>
#include <components/esm4/loadingr.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadmisc.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadtree.hpp>
#include <components/esm4/loadweap.hpp>
#include "../mwworld/cellstore.hpp"
#include "../mwworld/worldmodel.hpp"

2
apps/openmw/mwlua/luabindings.cpp
View File

@ -127,7 +127,7 @@ namespace MWLua
const std::vector<std::string>& contentList = MWBase::Environment::get().getWorld()->getContentFiles();
for (size_t i = 0; i < contentList.size(); ++i)
if (Misc::StringUtils::ciEqual(contentList[i], contentFile))
return ESM::RefId(ESM::FormIdRefId(ESM::FormId{ index, int(i) })).serializeText();
return ESM::RefId(ESM::FormId{ index, int(i) }).serializeText();
throw std::runtime_error("Content file not found: " + std::string(contentFile));
};
addTimeBindings(api, context, false);

9
apps/openmw/mwlua/types/door.cpp
View File

@ -100,10 +100,11 @@ namespace MWLua
addRecordFunctionBinding<ESM4::Door>(door, context, "ESM4Door");
sol::usertype<ESM4::Door> record = context.mLua->sol().new_usertype<ESM4::Door>("ESM4_Door");
record[sol::meta_function::to_string]
= [](const ESM4::Door& rec) -> std::string { return "ESM4_Door[" + rec.mId.toDebugString() + "]"; };
record["id"]
= sol::readonly_property([](const ESM4::Door& rec) -> std::string { return rec.mId.serializeText(); });
record[sol::meta_function::to_string] = [](const ESM4::Door& rec) -> std::string {
return "ESM4_Door[" + ESM::RefId(rec.mId).toDebugString() + "]";
};
record["id"] = sol::readonly_property(
[](const ESM4::Door& rec) -> std::string { return ESM::RefId(rec.mId).serializeText(); });
record["name"] = sol::readonly_property([](const ESM4::Door& rec) -> std::string { return rec.mFullName; });
record["model"] = sol::readonly_property([vfs](const ESM4::Door& rec) -> std::string {
return Misc::ResourceHelpers::correctMeshPath(rec.mModel, vfs);

2
apps/openmw/mwworld/cell.cpp
View File

@ -21,7 +21,7 @@ namespace MWWorld
if (!value.mEditorId.empty())
return value.mEditorId;
return value.mId.serializeText();
return ESM::RefId(value.mId).serializeText();
}
std::string getCellDescription(const ESM4::Cell& cell, const ESM4::World* world)

8
apps/openmw/mwworld/cellref.hpp
View File

@ -125,13 +125,7 @@ namespace MWWorld
// The NPC that owns this object (and will get angry if you steal it)
ESM::RefId getOwner() const
{
struct Visitor
{
ESM::RefId operator()(const ESM::CellRef& ref) { return ref.mOwner; }
ESM::RefId operator()(const ESM4::Reference& ref) { return ESM::RefId::formIdRefId(ref.mOwner); }
ESM::RefId operator()(const ESM4::ActorCharacter& ref) { return ESM::RefId::formIdRefId(ref.mOwner); }
};
return std::visit(Visitor(), mCellRef.mVariant);
return std::visit([](auto&& ref) -> ESM::RefId { return ref.mOwner; }, mCellRef.mVariant);
}
void setOwner(const ESM::RefId& owner);

21
apps/openmw/mwworld/cellstore.cpp
View File

@ -7,7 +7,6 @@
#include <components/debug/debuglog.hpp>
#include <components/esm/format.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/cellref.hpp>
#include <components/esm3/cellstate.hpp>
#include <components/esm3/containerstate.hpp>
@ -41,11 +40,29 @@
#include <components/esm3/npcstate.hpp>
#include <components/esm3/objectstate.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/esm4/loadachr.hpp>
#include <components/esm4/loadacti.hpp>
#include <components/esm4/loadalch.hpp>
#include <components/esm4/loadammo.hpp>
#include <components/esm4/loadarmo.hpp>
#include <components/esm4/loadbook.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loadclot.hpp>
#include <components/esm4/loadcont.hpp>
#include <components/esm4/loadcrea.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadfurn.hpp>
#include <components/esm4/loadingr.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadmisc.hpp>
#include <components/esm4/loadnpc.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadtree.hpp>
#include <components/esm4/loadweap.hpp>
#include <components/esm4/readerutils.hpp>
#include <components/files/openfile.hpp>
#include <components/misc/tuplehelpers.hpp>
#include <components/resource/resourcesystem.hpp>
@ -387,7 +404,7 @@ namespace MWWorld
static constexpr bool isESM4ActorRec(unsigned int rec)
{
return rec == ESM::REC_NPC_4 || rec == ESM::REC_CREA4 || rec == ESM::REC_LVLN4 || rec == ESM::REC_LVLC4;
return rec == ESM::REC_NPC_4 || rec == ESM::REC_CREA4;
}
template <typename X, typename R>

18
apps/openmw/mwworld/esmstore.cpp
View File

@ -5,20 +5,18 @@
#include <tuple>
#include <components/debug/debuglog.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/readerscache.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/lua/configuration.hpp>
#include <components/misc/algorithm.hpp>
#include <components/esm4/common.hpp>
#include <components/esm4/loadland.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/esm4/reader.hpp>
#include <components/esm4/readerutils.hpp>
#include <components/esmloader/load.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/lua/configuration.hpp>
#include <components/misc/algorithm.hpp>
#include "../mwmechanics/spelllist.hpp"
@ -278,10 +276,6 @@ namespace MWWorld
case ESM::REC_STAT:
case ESM::REC_WEAP:
case ESM::REC_BODY:
case ESM::REC_ACHR4:
case ESM::REC_ACRE4:
case ESM::REC_STAT4:
case ESM::REC_LIGH4:
case ESM::REC_ACTI4:
case ESM::REC_ALCH4:
case ESM::REC_AMMO4:
@ -292,11 +286,13 @@ namespace MWWorld
case ESM::REC_DOOR4:
case ESM::REC_FURN4:
case ESM::REC_INGR4:
case ESM::REC_LIGH4:
case ESM::REC_LVLI4:
case ESM::REC_LVLC4:
case ESM::REC_LVLN4:
case ESM::REC_MISC4:
case ESM::REC_NPC_4:
case ESM::REC_RACE4:
case ESM::REC_STAT4:
case ESM::REC_TREE4:
case ESM::REC_WEAP4:
return true;

126
apps/openmw/mwworld/esmstore.hpp
View File

@ -24,82 +24,87 @@ namespace MWMechanics
class SpellList;
}
namespace ESM
{
class ReadersCache;
class Script;
struct Activator;
struct Apparatus;
struct Armor;
struct Attribute;
struct BirthSign;
struct BodyPart;
struct Book;
struct Cell;
struct Class;
struct Clothing;
struct Container;
struct Creature;
struct CreatureLevList;
struct Dialogue;
struct Door;
struct Enchantment;
struct Faction;
struct GameSetting;
struct Global;
struct Ingredient;
struct ItemLevList;
struct Land;
struct LandTexture;
struct Light;
struct Lockpick;
struct MagicEffect;
struct Miscellaneous;
struct NPC;
struct Pathgrid;
struct Potion;
struct Probe;
struct Race;
struct Region;
struct Repair;
struct Skill;
struct Sound;
struct SoundGenerator;
struct Spell;
struct StartScript;
struct Static;
struct Weapon;
}
namespace ESM4
{
class Reader;
struct Static;
struct Cell;
struct Light;
struct Reference;
struct Activator;
struct ActorCharacter;
struct ActorCreature;
struct Activator;
struct Potion;
struct Ammunition;
struct Armor;
struct ArmorAddon;
struct Book;
struct Cell;
struct Clothing;
struct Container;
struct Creature;
struct Door;
struct Furniture;
struct Hair;
struct HeadPart;
struct Ingredient;
struct Land;
struct LevelledCreature;
struct LevelledItem;
struct LevelledNpc;
struct Light;
struct MiscItem;
struct Npc;
struct Outfit;
struct Potion;
struct Race;
struct Reference;
struct Static;
struct Tree;
struct Weapon;
struct World;
struct Land;
}
namespace ESM
{
class ReadersCache;
struct Activator;
struct Potion;
struct Apparatus;
struct Armor;
struct BodyPart;
struct Book;
struct BirthSign;
struct Class;
struct Clothing;
struct Container;
struct Creature;
struct Dialogue;
struct Door;
struct Enchantment;
struct Faction;
struct Global;
struct Ingredient;
struct CreatureLevList;
struct ItemLevList;
struct Light;
struct Lockpick;
struct Miscellaneous;
struct NPC;
struct Probe;
struct Race;
struct Region;
struct Repair;
struct SoundGenerator;
struct Sound;
struct Spell;
struct StartScript;
struct Static;
struct Weapon;
struct GameSetting;
class Script;
struct Cell;
struct Land;
struct LandTexture;
struct Pathgrid;
struct MagicEffect;
struct Skill;
struct Attribute;
}
namespace MWWorld
@ -128,12 +133,13 @@ namespace MWWorld
// Special entry which is hardcoded and not loaded from an ESM
Store<ESM::Attribute>,
Store<ESM4::Static>, Store<ESM4::Cell>, Store<ESM4::Light>, Store<ESM4::Reference>, Store<ESM4::Activator>,
Store<ESM4::Potion>, Store<ESM4::Ammunition>, Store<ESM4::Armor>, Store<ESM4::Book>, Store<ESM4::Clothing>,
Store<ESM4::Container>, Store<ESM4::Door>, Store<ESM4::Ingredient>, Store<ESM4::MiscItem>,
Store<ESM4::Tree>, Store<ESM4::Weapon>, Store<ESM4::World>, Store<ESM4::Furniture>, Store<ESM4::Land>,
Store<ESM4::ActorCharacter>, Store<ESM4::ActorCreature>, Store<ESM4::Race>, Store<ESM4::Creature>,
Store<ESM4::LevelledCreature>, Store<ESM4::Npc>, Store<ESM4::LevelledNpc>>;
Store<ESM4::Activator>, Store<ESM4::ActorCharacter>, Store<ESM4::ActorCreature>, Store<ESM4::Ammunition>,
Store<ESM4::Armor>, Store<ESM4::ArmorAddon>, Store<ESM4::Book>, Store<ESM4::Cell>, Store<ESM4::Clothing>,
Store<ESM4::Container>, Store<ESM4::Creature>, Store<ESM4::Door>, Store<ESM4::Furniture>, Store<ESM4::Hair>,
Store<ESM4::HeadPart>, Store<ESM4::Ingredient>, Store<ESM4::Land>, Store<ESM4::LevelledCreature>,
Store<ESM4::LevelledItem>, Store<ESM4::LevelledNpc>, Store<ESM4::Light>, Store<ESM4::MiscItem>,
Store<ESM4::Npc>, Store<ESM4::Outfit>, Store<ESM4::Potion>, Store<ESM4::Race>, Store<ESM4::Reference>,
Store<ESM4::Static>, Store<ESM4::Tree>, Store<ESM4::Weapon>, Store<ESM4::World>>;
private:
template <typename T>

30
apps/openmw/mwworld/store.cpp
View File

@ -5,11 +5,11 @@
#include <stdexcept>
#include <components/debug/debuglog.hpp>
#include <components/esm/records.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <components/esm4/loadland.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/fallback/fallback.hpp>
#include <components/loadinglistener/loadinglistener.hpp>
#include <components/misc/rng.hpp>
@ -172,7 +172,7 @@ namespace MWWorld
if (!mShared.empty())
return mShared[Misc::Rng::rollDice(mShared.size(), prng)];
}
else
else if constexpr (!std::is_same_v<decltype(T::mId), ESM::FormId>)
{
std::vector<const T*> results;
std::copy_if(mShared.begin(), mShared.end(), std::back_inserter(results),
@ -1371,29 +1371,35 @@ template class MWWorld::TypedDynamicStore<ESM::StartScript>;
template class MWWorld::TypedDynamicStore<ESM::Static>;
template class MWWorld::TypedDynamicStore<ESM::Weapon>;
template class MWWorld::TypedDynamicStore<ESM4::Reference, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::ActorCharacter, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::ActorCreature, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::Activator>;
template class MWWorld::TypedDynamicStore<ESM4::Potion>;
template class MWWorld::TypedDynamicStore<ESM4::Ammunition>;
template class MWWorld::TypedDynamicStore<ESM4::Armor>;
template class MWWorld::TypedDynamicStore<ESM4::ArmorAddon>;
template class MWWorld::TypedDynamicStore<ESM4::Book>;
template class MWWorld::TypedDynamicStore<ESM4::Cell>;
template class MWWorld::TypedDynamicStore<ESM4::Clothing>;
template class MWWorld::TypedDynamicStore<ESM4::Container>;
template class MWWorld::TypedDynamicStore<ESM4::Creature>;
template class MWWorld::TypedDynamicStore<ESM4::Door>;
template class MWWorld::TypedDynamicStore<ESM4::Furniture>;
template class MWWorld::TypedDynamicStore<ESM4::Hair>;
template class MWWorld::TypedDynamicStore<ESM4::HeadPart>;
template class MWWorld::TypedDynamicStore<ESM4::Ingredient>;
template class MWWorld::TypedDynamicStore<ESM4::MiscItem>;
template class MWWorld::TypedDynamicStore<ESM4::Static>;
template class MWWorld::TypedDynamicStore<ESM4::Tree>;
template class MWWorld::TypedDynamicStore<ESM4::Land>;
template class MWWorld::TypedDynamicStore<ESM4::LevelledCreature>;
template class MWWorld::TypedDynamicStore<ESM4::LevelledItem>;
template class MWWorld::TypedDynamicStore<ESM4::LevelledNpc>;
template class MWWorld::TypedDynamicStore<ESM4::Light>;
template class MWWorld::TypedDynamicStore<ESM4::MiscItem>;
template class MWWorld::TypedDynamicStore<ESM4::Npc>;
template class MWWorld::TypedDynamicStore<ESM4::Reference, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::ActorCharacter, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::ActorCreature, ESM::FormId>;
template class MWWorld::TypedDynamicStore<ESM4::Outfit>;
template class MWWorld::TypedDynamicStore<ESM4::Potion>;
template class MWWorld::TypedDynamicStore<ESM4::Race>;
template class MWWorld::TypedDynamicStore<ESM4::Cell>;
template class MWWorld::TypedDynamicStore<ESM4::Static>;
template class MWWorld::TypedDynamicStore<ESM4::Tree>;
template class MWWorld::TypedDynamicStore<ESM4::Weapon>;
template class MWWorld::TypedDynamicStore<ESM4::World>;
template class MWWorld::TypedDynamicStore<ESM4::Land>;

2
apps/openmw/mwworld/worldimp.cpp
View File

@ -711,7 +711,7 @@ namespace MWWorld
if (!activeOnly)
{
ret = mWorldModel.getPtr(name);
ret = mWorldModel.getPtrByRefId(name);
if (!ret.isEmpty())
return ret;
}

2
apps/openmw/mwworld/worldmodel.cpp
View File

@ -342,7 +342,7 @@ namespace MWWorld
}
}
MWWorld::Ptr MWWorld::WorldModel::getPtr(const ESM::RefId& name)
MWWorld::Ptr MWWorld::WorldModel::getPtrByRefId(const ESM::RefId& name)
{
for (const auto& [cachedId, cellStore] : mIdCache)
{

2
apps/openmw/mwworld/worldmodel.hpp
View File

@ -65,7 +65,7 @@ namespace MWWorld
CellStore& getCell(std::string_view name, bool forceLoad = true) const;
Ptr getPtr(const ESM::RefId& name);
Ptr getPtrByRefId(const ESM::RefId& name);
Ptr getPtr(ESM::RefNum refNum) const { return mPtrRegistry.getOrEmpty(refNum); }

10
apps/openmw_test_suite/esm/testrefid.cpp
View File

@ -208,11 +208,12 @@ namespace ESM
EXPECT_EQ(map.count(RefId::stringRefId("A")), 1);
}
TEST(ESMRefIdTest, stringRefIdIsNotEqualToFormId)
TEST(ESMRefIdTest, emptyRefId)
{
const RefId stringRefId = RefId::stringRefId("\0");
const RefId formIdRefId = RefId::formIdRefId({ .mIndex = 0, .mContentFile = 0 });
EXPECT_NE(stringRefId, formIdRefId);
EXPECT_EQ(RefId(), EmptyRefId());
EXPECT_EQ(RefId(), RefId::stringRefId("\0"));
EXPECT_EQ(RefId(), RefId::formIdRefId({ .mIndex = 0, .mContentFile = 0 }));
EXPECT_EQ(RefId(), RefId::formIdRefId({ .mIndex = 0, .mContentFile = -1 }));
}
TEST(ESMRefIdTest, indexRefIdHashDiffersForDistinctValues)
@ -337,7 +338,6 @@ namespace ESM
{ RefId::stringRefId("foo"), "foo" },
{ RefId::stringRefId("BAR"), "bar" },
{ RefId::stringRefId(std::string({ 'a', 0, -1, '\n', '\t' })), { 'a', 0, -1, '\n', '\t' } },
{ RefId::formIdRefId({ .mIndex = 0, .mContentFile = 0 }), "FormId:0x0" },
{ RefId::formIdRefId({ .mIndex = 1, .mContentFile = 0 }), "FormId:0x1" },
{ RefId::formIdRefId({ .mIndex = 0x1f, .mContentFile = 0 }), "FormId:0x1f" },
{ RefId::formIdRefId({ .mIndex = 0x1f, .mContentFile = 2 }), "FormId:0x200001f" },

1
apps/openmw_test_suite/esm4/includes.cpp
View File

@ -2,7 +2,6 @@
#include <components/esm4/common.hpp>
#include <components/esm4/dialogue.hpp>
#include <components/esm4/effect.hpp>
#include <components/esm4/formid.hpp>
#include <components/esm4/inventory.hpp>
#include <components/esm4/lighting.hpp>
#include <components/esm4/loadachr.hpp>

6
apps/openmw_test_suite/mwworld/test_store.cpp
View File

@ -16,12 +16,6 @@
#include <components/esm3/esmwriter.hpp>
#include <components/esm3/typetraits.hpp>
#include <components/esm4/common.hpp>
#include <components/esm4/loadcell.hpp>
#include <components/esm4/loadland.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadwrld.hpp>
#include <components/esm4/reader.hpp>
#include <components/esm4/readerutils.hpp>
#include <components/files/configurationmanager.hpp>

1
components/CMakeLists.txt
View File

@ -155,7 +155,6 @@ add_component_dir (esm4
common
dialogue
effect
formid
grid
grouptype
inventory

8
components/esm/formid.hpp
View File

@ -15,15 +15,15 @@ namespace ESM
uint32_t mIndex = 0;
int32_t mContentFile = -1;
bool hasContentFile() const { return mContentFile >= 0; }
bool isSet() const { return mIndex != 0 || mContentFile != -1; }
constexpr bool hasContentFile() const { return mContentFile >= 0; }
constexpr bool isSet() const { return mIndex != 0 || mContentFile != -1; }
// Zero is used in ESM4 as a null reference
bool isZeroOrUnset() const { return mIndex == 0 && (mContentFile == 0 || mContentFile == -1); }
constexpr bool isZeroOrUnset() const { return mIndex == 0 && (mContentFile == 0 || mContentFile == -1); }
std::string toString() const;
FormId32 toUint32() const;
static FormId fromUint32(FormId32 v) { return { v & 0xffffff, static_cast<int32_t>(v >> 24) }; }
static constexpr FormId fromUint32(FormId32 v) { return { v & 0xffffff, static_cast<int32_t>(v >> 24) }; }
};
inline constexpr bool operator==(const FormId& left, const FormId& right)

94
components/esm/records.hpp
View File

@ -1,51 +1,53 @@
#ifndef OPENMW_ESM_RECORDS_H
#define OPENMW_ESM_RECORDS_H
#include "components/esm3/loadacti.hpp"
#include "components/esm3/loadalch.hpp"
#include "components/esm3/loadappa.hpp"
#include "components/esm3/loadarmo.hpp"
#include "components/esm3/loadbody.hpp"
#include "components/esm3/loadbook.hpp"
#include "components/esm3/loadbsgn.hpp"
#include "components/esm3/loadcell.hpp"
#include "components/esm3/loadclas.hpp"
#include "components/esm3/loadclot.hpp"
#include "components/esm3/loadcont.hpp"
#include "components/esm3/loadcrea.hpp"
#include "components/esm3/loaddial.hpp"
#include "components/esm3/loaddoor.hpp"
#include "components/esm3/loadench.hpp"
#include "components/esm3/loadfact.hpp"
#include "components/esm3/loadglob.hpp"
#include "components/esm3/loadgmst.hpp"
#include "components/esm3/loadinfo.hpp"
#include "components/esm3/loadingr.hpp"
#include "components/esm3/loadland.hpp"
#include "components/esm3/loadlevlist.hpp"
#include "components/esm3/loadligh.hpp"
#include "components/esm3/loadlock.hpp"
#include "components/esm3/loadltex.hpp"
#include "components/esm3/loadmgef.hpp"
#include "components/esm3/loadmisc.hpp"
#include "components/esm3/loadnpc.hpp"
#include "components/esm3/loadpgrd.hpp"
#include "components/esm3/loadprob.hpp"
#include "components/esm3/loadrace.hpp"
#include "components/esm3/loadregn.hpp"
#include "components/esm3/loadrepa.hpp"
#include "components/esm3/loadscpt.hpp"
#include "components/esm3/loadskil.hpp"
#include "components/esm3/loadsndg.hpp"
#include "components/esm3/loadsoun.hpp"
#include "components/esm3/loadspel.hpp"
#include "components/esm3/loadsscr.hpp"
#include "components/esm3/loadstat.hpp"
#include "components/esm3/loadweap.hpp"
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadappa.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadbody.hpp>
#include <components/esm3/loadbook.hpp>
#include <components/esm3/loadbsgn.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm3/loadclas.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loaddial.hpp>
#include <components/esm3/loaddoor.hpp>
#include <components/esm3/loadench.hpp>
#include <components/esm3/loadfact.hpp>
#include <components/esm3/loadglob.hpp>
#include <components/esm3/loadgmst.hpp>
#include <components/esm3/loadinfo.hpp>
#include <components/esm3/loadingr.hpp>
#include <components/esm3/loadland.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadlock.hpp>
#include <components/esm3/loadltex.hpp>
#include <components/esm3/loadmgef.hpp>
#include <components/esm3/loadmisc.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadpgrd.hpp>
#include <components/esm3/loadprob.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/loadregn.hpp>
#include <components/esm3/loadrepa.hpp>
#include <components/esm3/loadscpt.hpp>
#include <components/esm3/loadskil.hpp>
#include <components/esm3/loadsndg.hpp>
#include <components/esm3/loadsoun.hpp>
#include <components/esm3/loadspel.hpp>
#include <components/esm3/loadsscr.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/loadweap.hpp>
#include <components/esm4/loadachr.hpp>
#include <components/esm4/loadacti.hpp>
#include <components/esm4/loadalch.hpp>
#include <components/esm4/loadammo.hpp>
#include <components/esm4/loadarma.hpp>
#include <components/esm4/loadarmo.hpp>
#include <components/esm4/loadbook.hpp>
#include <components/esm4/loadcell.hpp>
@ -54,20 +56,24 @@
#include <components/esm4/loadcrea.hpp>
#include <components/esm4/loaddoor.hpp>
#include <components/esm4/loadfurn.hpp>
#include <components/esm4/loadhair.hpp>
#include <components/esm4/loadhdpt.hpp>
#include <components/esm4/loadingr.hpp>
#include <components/esm4/loadland.hpp>
#include <components/esm4/loadligh.hpp>
#include <components/esm4/loadlvlc.hpp>
#include <components/esm4/loadlvli.hpp>
#include <components/esm4/loadlvln.hpp>
#include <components/esm4/loadmisc.hpp>
#include <components/esm4/loadnpc.hpp>
#include <components/esm4/loadotft.hpp>
#include <components/esm4/loadrace.hpp>
#include <components/esm4/loadrefr.hpp>
#include <components/esm4/loadstat.hpp>
#include <components/esm4/loadtree.hpp>
#include <components/esm4/loadweap.hpp>
#include "defs.hpp"
#include <components/esm4/loadwrld.hpp>
// Special records which are not loaded from ESM
#include "components/esm/attr.hpp"
#include <components/esm/attr.hpp>
#endif

2
components/esm/refid.cpp
View File

@ -227,7 +227,7 @@ namespace ESM
uint64_t v = deserializeHexIntegral<uint64_t>(formIdRefIdPrefix.size(), value);
uint32_t index = static_cast<uint32_t>(v) & 0xffffff;
int contentFile = static_cast<int>(v >> 24);
return ESM::RefId::formIdRefId({ index, contentFile });
return ESM::FormId{ index, contentFile };
}
if (value.starts_with(generatedRefIdPrefix))

10
components/esm/refid.hpp
View File

@ -61,7 +61,7 @@ namespace ESM
static RefId stringRefId(std::string_view value);
// Constructs RefId from FormId storing the value in-place.
static RefId formIdRefId(FormId value) { return RefId(FormIdRefId(value)); }
static RefId formIdRefId(FormId value) { return RefId(value); }
// Constructs RefId from uint64 storing the value in-place. Should be used for generated records where id is a
// global counter.
@ -90,6 +90,14 @@ namespace ESM
{
}
constexpr RefId(FormId value)
{
if (value.isZeroOrUnset())
mValue = EmptyRefId();
else
mValue = FormIdRefId(value);
}
constexpr RefId(GeneratedRefId value) noexcept
: mValue(value)
{

4
components/esm4/actor.hpp
View File

@ -29,7 +29,7 @@
#include <cstdint>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -109,7 +109,7 @@ namespace ESM4
struct ActorFaction
{
FormId32 faction;
ESM::FormId32 faction;
std::int8_t rank;
std::uint8_t unknown1;
std::uint8_t unknown2;

2
components/esm4/cellgrid.hpp
View File

@ -29,8 +29,8 @@
#include <variant>
#include "formid.hpp"
#include "grid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{

4
components/esm4/effect.hpp
View File

@ -29,7 +29,7 @@
#include <cstdint>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -42,7 +42,7 @@ namespace ESM4
struct ScriptEffect
{
FormId32 formId; // Script effect (Magic effect must be SEFF)
ESM::FormId32 formId; // Script effect (Magic effect must be SEFF)
std::int32_t school; // Magic school. See Magic schools for more information.
EFI_Label visualEffect; // Visual effect name or 0x00000000 if None
std::uint8_t flags; // 0x01 = Hostile

41
components/esm4/formid.cpp
View File

@ -1,41 +0,0 @@
/*
Copyright (C) 2016, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
*/
#include "formid.hpp"
#include <stdexcept>
#include <string>
namespace ESM4
{
std::string formIdToString(const FormId& formId)
{
std::string str;
char buf[8 + 1];
int res = snprintf(buf, 8 + 1, "%08X", formId.toUint32());
if (res > 0 && res < 8 + 1)
str.assign(buf);
else
throw std::runtime_error("Possible buffer overflow while converting formId");
return str;
}
}

37
components/esm4/formid.hpp
View File

@ -1,37 +0,0 @@
/*
Copyright (C) 2016 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
*/
#ifndef ESM4_FORMID_H
#define ESM4_FORMID_H
#include <string>
#include <components/esm/formid.hpp>
namespace ESM4
{
using FormId = ESM::FormId;
using FormId32 = uint32_t;
std::string formIdToString(const FormId& formId);
}
#endif // ESM4_FORMID_H

6
components/esm4/inventory.hpp
View File

@ -29,7 +29,7 @@
#include <cstdint>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -39,14 +39,14 @@ namespace ESM4
{
std::int16_t level;
std::uint16_t unknown; // sometimes missing
FormId32 item;
ESM::FormId32 item;
std::int16_t count;
std::uint16_t unknown2; // sometimes missing
};
struct InventoryItem // NPC_, CREA, CONT
{
FormId32 item;
ESM::FormId32 item;
std::uint32_t count;
};
#pragma pack(pop)

11
components/esm4/loadachr.cpp
View File

@ -33,10 +33,9 @@
void ESM4::ActorCharacter::load(ESM4::Reader& reader)
{
mId = reader.hdr().record.getFormId();
reader.adjustFormId(mId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
mParent = ESM::RefId::formIdRefId(reader.currCell());
mParent = reader.currCell();
while (reader.getSubRecordHeader())
{
@ -50,12 +49,8 @@ void ESM4::ActorCharacter::load(ESM4::Reader& reader)
reader.getZString(mFullName);
break;
case ESM4::SUB_NAME:
{
FormId baseId;
reader.getFormId(baseId);
mBaseObj = ESM::RefId::formIdRefId(baseId);
reader.getFormId(mBaseObj);
break;
}
case ESM4::SUB_DATA:
reader.get(mPos);
break;

4
components/esm4/loadachr.hpp
View File

@ -32,7 +32,7 @@
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "reference.hpp" // FormId, Placement, EnableParent
#include "reference.hpp" // Placement, EnableParent
namespace ESM4
{
@ -48,7 +48,7 @@ namespace ESM4
std::string mEditorId;
std::string mFullName;
ESM::RefId mBaseObj;
ESM::FormId mBaseObj;
ESM::Position mPos;
float mScale = 1.0f;

2
components/esm4/loadacti.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Activator::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

16
components/esm4/loadacti.hpp
View File

@ -31,9 +31,7 @@
#include <string>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -42,21 +40,21 @@ namespace ESM4
struct Activator
{
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
std::string mFullName;
std::string mModel;
FormId mScriptId;
FormId mLoopingSound; // SOUN
FormId mActivationSound; // SOUN
ESM::FormId mScriptId;
ESM::FormId mLoopingSound; // SOUN
ESM::FormId mActivationSound; // SOUN
float mBoundRadius;
FormId mRadioTemplate; // SOUN
FormId mRadioStation; // TACT
ESM::FormId mRadioTemplate; // SOUN
ESM::FormId mRadioStation; // TACT
std::string mActivationPrompt;

2
components/esm4/loadalch.cpp
View File

@ -34,7 +34,7 @@
void ESM4::Potion::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

14
components/esm4/loadalch.hpp
View File

@ -31,7 +31,7 @@
#include <string>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include <components/esm/formid.hpp>
#include "effect.hpp" // FormId, ScriptEffect
@ -52,13 +52,13 @@ namespace ESM4
{
std::int32_t value;
std::uint32_t flags;
FormId32 withdrawl;
ESM::FormId32 withdrawl;
float chanceAddition;
FormId32 sound;
ESM::FormId32 sound;
};
#pragma pack(pop)
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -67,10 +67,10 @@ namespace ESM4
std::string mIcon; // inventory
std::string mMiniIcon; // inventory
FormId mPickUpSound;
FormId mDropSound;
ESM::FormId mPickUpSound;
ESM::FormId mDropSound;
FormId mScriptId;
ESM::FormId mScriptId;
ScriptEffect mEffect;
float mBoundRadius;

47
components/esm4/loadaloc.cpp
View File

@ -29,15 +29,12 @@
#include <cstring>
#include <stdexcept>
//#include "formid.hpp" // FIXME:
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::MediaLocationController::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -52,53 +49,23 @@ void ESM4::MediaLocationController::load(ESM4::Reader& reader)
reader.getZString(mFullName);
break;
case ESM4::SUB_GNAM:
{
FormId id;
reader.getFormId(id);
mBattleSets.push_back(id);
reader.getFormId(mBattleSets.emplace_back());
break;
}
case ESM4::SUB_LNAM:
{
FormId id;
reader.getFormId(id);
mLocationSets.push_back(id);
reader.getFormId(mLocationSets.emplace_back());
break;
}
case ESM4::SUB_YNAM:
{
FormId id;
reader.getFormId(id);
mEnemySets.push_back(id);
reader.getFormId(mEnemySets.emplace_back());
break;
}
case ESM4::SUB_HNAM:
{
FormId id;
reader.getFormId(id);
mNeutralSets.push_back(id);
reader.getFormId(mNeutralSets.emplace_back());
break;
}
case ESM4::SUB_XNAM:
{
FormId id;
reader.getFormId(id);
mFriendSets.push_back(id);
reader.getFormId(mFriendSets.emplace_back());
break;
}
case ESM4::SUB_ZNAM:
{
FormId id;
reader.getFormId(id);
mAllySets.push_back(id);
reader.getFormId(mAllySets.emplace_back());
break;
}
case ESM4::SUB_RNAM:
reader.getFormId(mConditionalFaction);
break;

20
components/esm4/loadaloc.hpp
View File

@ -31,7 +31,8 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -52,22 +53,22 @@ namespace ESM4
struct MediaLocationController
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
std::string mFullName;
std::vector<FormId> mBattleSets;
std::vector<FormId> mLocationSets;
std::vector<FormId> mEnemySets;
std::vector<FormId> mNeutralSets;
std::vector<FormId> mFriendSets;
std::vector<FormId> mAllySets;
std::vector<ESM::FormId> mBattleSets;
std::vector<ESM::FormId> mLocationSets;
std::vector<ESM::FormId> mEnemySets;
std::vector<ESM::FormId> mNeutralSets;
std::vector<ESM::FormId> mFriendSets;
std::vector<ESM::FormId> mAllySets;
MLC_Flags mMediaFlags;
FormId mConditionalFaction;
ESM::FormId mConditionalFaction;
float mLocationDelay;
float mRetriggerDelay;
@ -79,6 +80,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_ALOC4;
};
}

8
components/esm4/loadammo.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Ammunition::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -128,12 +128,8 @@ void ESM4::Ammunition::load(ESM4::Reader& reader)
reader.getLocalizedString(mAbbrev);
break;
case ESM4::SUB_RCIL:
{
FormId effect;
reader.getFormId(effect);
mAmmoEffects.push_back(effect);
reader.getFormId(mAmmoEffects.emplace_back());
break;
}
case ESM4::SUB_SCRI:
reader.getFormId(mScript);
break;

20
components/esm4/loadammo.hpp
View File

@ -32,9 +32,7 @@
#include <vector>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -52,12 +50,12 @@ namespace ESM4
float mDamage{ 0.f };
std::uint8_t mClipRounds{ 0u };
std::uint32_t mProjPerShot{ 0u };
FormId mProjectile;
FormId mConsumedAmmo;
ESM::FormId mProjectile;
ESM::FormId mConsumedAmmo;
float mConsumedPercentage{ 0.f };
};
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -69,17 +67,17 @@ namespace ESM4
std::string mIcon; // inventory
std::string mMiniIcon; // inventory
FormId mPickUpSound;
FormId mDropSound;
ESM::FormId mPickUpSound;
ESM::FormId mDropSound;
float mBoundRadius;
std::uint16_t mEnchantmentPoints;
FormId mEnchantment;
ESM::FormId mEnchantment;
std::vector<FormId> mAmmoEffects;
std::vector<ESM::FormId> mAmmoEffects;
FormId mScript;
ESM::FormId mScript;
Data mData;

3
components/esm4/loadanio.cpp
View File

@ -33,8 +33,7 @@
void ESM4::AnimObject::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

8
components/esm4/loadanio.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -39,7 +40,7 @@ namespace ESM4
struct AnimObject
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -47,13 +48,14 @@ namespace ESM4
float mBoundRadius;
FormId mIdleAnim; // only in TES4
ESM::FormId mIdleAnim; // only in TES4
std::string mUnloadEvent; // only in TES5
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_ANIO4;
};
}

3
components/esm4/loadappa.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Apparatus::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

8
components/esm4/loadappa.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -47,7 +48,7 @@ namespace ESM4
float quality;
};
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -58,7 +59,7 @@ namespace ESM4
float mBoundRadius;
FormId mScriptId;
ESM::FormId mScriptId;
Data mData;
@ -66,6 +67,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_APPA4;
};
}

9
components/esm4/loadarma.cpp
View File

@ -33,8 +33,7 @@
void ESM4::ArmorAddon::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
@ -71,11 +70,7 @@ void ESM4::ArmorAddon::load(ESM4::Reader& reader)
break;
case ESM4::SUB_MODL:
if ((esmVer == ESM::VER_094 || esmVer == ESM::VER_170) && subHdr.dataSize == 4) // TES5
{
FormId formId;
reader.getFormId(formId);
mRaces.push_back(formId);
}
reader.getFormId(mRaces.emplace_back());
else
reader.skipSubRecordData(); // FIXME: this should be mModelMale for FO3/FONV

15
components/esm4/loadarma.hpp
View File

@ -31,8 +31,10 @@
#include <string>
#include <vector>
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
#include "actor.hpp" // BodyTemplate
#include "formid.hpp"
namespace ESM4
{
@ -41,7 +43,7 @@ namespace ESM4
struct ArmorAddon
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -49,11 +51,11 @@ namespace ESM4
std::string mModelMale;
std::string mModelFemale;
FormId mTextureMale;
FormId mTextureFemale;
ESM::FormId mTextureMale;
ESM::FormId mTextureFemale;
FormId mRacePrimary;
std::vector<FormId> mRaces; // TES5 only
ESM::FormId mRacePrimary;
std::vector<ESM::FormId> mRaces; // TES5 only
BodyTemplate mBodyTemplate; // TES5
@ -61,6 +63,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_ARMA4;
};
}

9
components/esm4/loadarmo.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Armor::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
mIsFONV = esmVer == ESM::VER_132 || esmVer == ESM::VER_133 || esmVer == ESM::VER_134;
@ -76,12 +76,7 @@ void ESM4::Armor::load(ESM4::Reader& reader)
{
// if (esmVer == ESM::VER_094 || esmVer == ESM::VER_170 || isFONV)
if (subHdr.dataSize == 4) // FO3 has zstring even though VER_094
{
FormId formId;
reader.getFormId(formId);
mAddOns.push_back(formId);
}
reader.getFormId(mAddOns.emplace_back());
else
{
if (!reader.getZString(mModelMale))

16
components/esm4/loadarmo.hpp
View File

@ -32,9 +32,7 @@
#include <vector>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -151,7 +149,7 @@ namespace ESM4
};
#pragma pack(pop)
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
bool mIsTES4; // TODO: check that these match the general flags
@ -170,8 +168,8 @@ namespace ESM4
std::string mIconFemale;
std::string mMiniIconFemale;
FormId mPickUpSound;
FormId mDropSound;
ESM::FormId mPickUpSound;
ESM::FormId mDropSound;
std::string mModel; // FIXME: for OpenCS
@ -179,11 +177,11 @@ namespace ESM4
std::uint32_t mArmorFlags;
std::uint32_t mGeneralFlags;
FormId mScriptId;
ESM::FormId mScriptId;
std::uint16_t mEnchantmentPoints;
FormId mEnchantment;
ESM::FormId mEnchantment;
std::vector<FormId> mAddOns; // TES5 ARMA
std::vector<ESM::FormId> mAddOns; // TES5 ARMA
Data mData;
void load(ESM4::Reader& reader);

9
components/esm4/loadaspc.cpp
View File

@ -33,8 +33,7 @@
void ESM4::AcousticSpace::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -49,12 +48,8 @@ void ESM4::AcousticSpace::load(ESM4::Reader& reader)
reader.get(mEnvironmentType);
break;
case ESM4::SUB_SNAM:
{
FormId id;
reader.getFormId(id);
mAmbientLoopSounds.push_back(id);
reader.getFormId(mAmbientLoopSounds.emplace_back());
break;
}
case ESM4::SUB_RDAT:
reader.getFormId(mSoundRegion);
break;

10
components/esm4/loadaspc.hpp
View File

@ -31,7 +31,8 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -40,7 +41,7 @@ namespace ESM4
struct AcousticSpace
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -48,8 +49,8 @@ namespace ESM4
std::uint32_t mEnvironmentType;
// 0 Dawn (5:00 start), 1 Afternoon (8:00), 2 Dusk (18:00), 3 Night (20:00)
std::vector<FormId> mAmbientLoopSounds;
FormId mSoundRegion;
std::vector<ESM::FormId> mAmbientLoopSounds;
ESM::FormId mSoundRegion;
std::uint32_t mIsInterior; // if true only use mAmbientLoopSounds[0]
@ -57,6 +58,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_ASPC4;
};
}

2
components/esm4/loadbook.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Book::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
// std::uint32_t esmVer = reader.esmVersion(); // currently unused

14
components/esm4/loadbook.hpp
View File

@ -31,9 +31,7 @@
#include <string>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -84,7 +82,7 @@ namespace ESM4
float weight;
};
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -94,15 +92,15 @@ namespace ESM4
float mBoundRadius;
std::string mText;
FormId mScriptId;
ESM::FormId mScriptId;
std::string mIcon;
std::uint16_t mEnchantmentPoints;
FormId mEnchantment;
ESM::FormId mEnchantment;
Data mData;
FormId mPickUpSound;
FormId mDropSound;
ESM::FormId mPickUpSound;
ESM::FormId mDropSound;
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;

3
components/esm4/loadbptd.cpp
View File

@ -45,8 +45,7 @@ void ESM4::BodyPartData::BodyPart::clear()
void ESM4::BodyPartData::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
BodyPart bodyPart;

18
components/esm4/loadbptd.hpp
View File

@ -31,7 +31,8 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -68,14 +69,14 @@ namespace ESM4
std::uint8_t explExplosionChance; // %
std::uint16_t explDebrisCount;
FormId32 explDebris;
FormId32 explExplosion;
ESM::FormId32 explDebris;
ESM::FormId32 explExplosion;
float trackingMaxAngle;
float explDebrisScale;
std::int32_t sevDebrisCount;
FormId32 sevDebris;
FormId32 sevExplosion;
ESM::FormId32 sevDebris;
ESM::FormId32 sevExplosion;
float sevDebrisScale;
// Struct - Gore Effects Positioning
@ -86,8 +87,8 @@ namespace ESM4
float rotY;
float rotZ;
FormId32 sevImpactDataSet;
FormId32 explImpactDataSet;
ESM::FormId32 sevImpactDataSet;
ESM::FormId32 explImpactDataSet;
uint8_t sevDecalCount;
uint8_t explDecalCount;
uint16_t Unknown;
@ -108,7 +109,7 @@ namespace ESM4
void clear();
};
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -121,6 +122,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_BPTD4;
};
}

13
components/esm4/loadcell.cpp
View File

@ -47,11 +47,10 @@ float ESM4::Cell::sInvalidWaterLevel = -200000.f;
// longer/shorter/same as loading the subrecords.
void ESM4::Cell::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = ESM::RefId::formIdRefId(mFormId);
ESM::FormId formId = reader.getFormIdFromHeader();
mId = formId;
mFlags = reader.hdr().record.flags;
mParent = ESM::RefId::formIdRefId(reader.currWorld());
mParent = reader.currWorld();
mWaterHeight = sInvalidWaterLevel;
reader.clearCellGrid(); // clear until XCLC FIXME: somehow do this automatically?
@ -70,7 +69,7 @@ void ESM4::Cell::load(ESM4::Reader& reader)
// WARN: we need to call setCurrCell (and maybe setCurrCellGrid?) again before loading
// cell child groups if we are loading them after restoring the context
// (may be easier to update the context before saving?)
reader.setCurrCell(mFormId); // save for LAND (and other children) to access later
reader.setCurrCell(formId); // save for LAND (and other children) to access later
std::uint32_t esmVer = reader.esmVersion();
bool isFONV = esmVer == ESM::VER_132 || esmVer == ESM::VER_133 || esmVer == ESM::VER_134;
bool isSkyrim = (esmVer == ESM::VER_170 || esmVer == ESM::VER_094);
@ -155,8 +154,8 @@ void ESM4::Cell::load(ESM4::Reader& reader)
}
case ESM4::SUB_XCLR: // for exterior cells
{
mRegions.resize(subHdr.dataSize / sizeof(FormId32));
for (std::vector<FormId>::iterator it = mRegions.begin(); it != mRegions.end(); ++it)
mRegions.resize(subHdr.dataSize / sizeof(ESM::FormId32));
for (std::vector<ESM::FormId>::iterator it = mRegions.begin(); it != mRegions.end(); ++it)
{
reader.getFormId(*it);
#if 0

24
components/esm4/loadcell.hpp
View File

@ -31,14 +31,13 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include "lighting.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include <components/esm/util.hpp>
#include <components/esm4/reader.hpp>
#include "lighting.hpp"
namespace ESM4
{
class Reader;
@ -63,8 +62,7 @@ namespace ESM4
// The cells need to be organised under world spaces.
struct Cell
{
FormId mFormId; // from the header
ESM::RefId mId;
ESM::RefId mId; // from the header
std::uint32_t mFlags = 0; // from the header, see enum type RecordFlag for details
ESM::RefId mParent; // world formId (for grouping cells), from the loading sequence
@ -76,20 +74,20 @@ namespace ESM4
std::int32_t mX = 0;
std::int32_t mY = 0;
FormId mOwner;
FormId mGlobal;
FormId mClimate;
FormId mWater;
ESM::FormId mOwner;
ESM::FormId mGlobal;
ESM::FormId mClimate;
ESM::FormId mWater;
float mWaterHeight = sInvalidWaterLevel;
std::vector<FormId> mRegions;
std::vector<ESM::FormId> mRegions;
Lighting mLighting;
FormId mLightingTemplate; // FO3/FONV
ESM::FormId mLightingTemplate; // FO3/FONV
std::uint32_t mLightingTemplateFlags = 0; // FO3/FONV
FormId mMusic; // FO3/FONV
FormId mAcousticSpace; // FO3/FONV
ESM::FormId mMusic; // FO3/FONV
ESM::FormId mAcousticSpace; // FO3/FONV
// TES4: 0 = default, 1 = public, 2 = dungeon
// FO3/FONV have more types (not sure how they are used, however)
std::uint8_t mMusicType = 0;

3
components/esm4/loadclas.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Class::load(ESM4::Reader& reader)
{
// mFormId = reader.adjustFormId(reader.hdr().record.id); // FIXME: use master adjusted?
mFormId = reader.hdr().record.getFormId();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadclas.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -44,7 +45,7 @@ namespace ESM4
std::uint32_t attr;
};
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -57,6 +58,7 @@ namespace ESM4
// void save(ESM4::Writer& reader) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::REC_CLAS4;
};
}

3
components/esm4/loadclfm.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Colour::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadclfm.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -48,7 +49,7 @@ namespace ESM4
struct Colour
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -61,6 +62,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::REC_CLFM4;
};
}

2
components/esm4/loadclot.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Clothing::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

10
components/esm4/loadclot.hpp
View File

@ -31,9 +31,7 @@
#include <string>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -50,7 +48,7 @@ namespace ESM4
};
#pragma pack(pop)
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -67,9 +65,9 @@ namespace ESM4
float mBoundRadius;
std::uint32_t mClothingFlags; // see Armor::ArmorFlags for the values
FormId mScriptId;
ESM::FormId mScriptId;
std::uint16_t mEnchantmentPoints;
FormId mEnchantment;
ESM::FormId mEnchantment;
Data mData;

2
components/esm4/loadcont.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Container::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

11
components/esm4/loadcont.hpp
View File

@ -32,9 +32,8 @@
#include <vector>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include <components/esm/formid.hpp>
#include "formid.hpp"
#include "inventory.hpp" // InventoryItem
namespace ESM4
@ -44,7 +43,7 @@ namespace ESM4
struct Container
{
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -55,9 +54,9 @@ namespace ESM4
unsigned char mDataFlags;
float mWeight;
FormId mOpenSound;
FormId mCloseSound;
FormId mScriptId; // TES4 only
ESM::FormId mOpenSound;
ESM::FormId mCloseSound;
ESM::FormId mScriptId; // TES4 only
std::vector<InventoryItem> mInventory;

20
components/esm4/loadcrea.cpp
View File

@ -37,7 +37,7 @@
void ESM4::Creature::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -63,19 +63,11 @@ void ESM4::Creature::load(ESM4::Reader& reader)
break;
}
case ESM4::SUB_SPLO:
{
FormId id;
reader.getFormId(id);
mSpell.push_back(id);
reader.getFormId(mSpell.emplace_back());
break;
}
case ESM4::SUB_PKID:
{
FormId id;
reader.getFormId(id);
mAIPackages.push_back(id);
reader.getFormId(mAIPackages.emplace_back());
break;
}
case ESM4::SUB_SNAM:
reader.get(mFaction);
reader.adjustFormId(mFaction.faction);
@ -163,12 +155,8 @@ void ESM4::Creature::load(ESM4::Reader& reader)
reader.getFormId(mBaseTemplate);
break; // FO3
case ESM4::SUB_PNAM: // FO3/FONV/TES5
{
FormId bodyPart;
reader.getFormId(bodyPart);
mBodyParts.push_back(bodyPart);
reader.getFormId(mBodyParts.emplace_back());
break;
}
case ESM4::SUB_MODT:
case ESM4::SUB_RNAM:
case ESM4::SUB_CSDT:

22
components/esm4/loadcrea.hpp
View File

@ -32,7 +32,7 @@
#include <vector>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include <components/esm/formid.hpp>
#include "actor.hpp"
#include "inventory.hpp"
@ -106,25 +106,25 @@ namespace ESM4
};
#pragma pack(pop)
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
std::string mFullName;
std::string mModel;
FormId mDeathItem;
std::vector<FormId> mSpell;
FormId mScriptId;
ESM::FormId mDeathItem;
std::vector<ESM::FormId> mSpell;
ESM::FormId mScriptId;
AIData mAIData;
std::vector<FormId> mAIPackages;
std::vector<ESM::FormId> mAIPackages;
ActorBaseConfig mBaseConfig;
ActorFaction mFaction;
Data mData;
FormId mCombatStyle;
FormId mSoundBase;
FormId mSound;
ESM::FormId mCombatStyle;
ESM::FormId mSoundBase;
ESM::FormId mSound;
std::uint8_t mSoundChance;
float mBaseScale;
float mTurningSpeed;
@ -138,8 +138,8 @@ namespace ESM4
std::vector<InventoryItem> mInventory;
FormId mBaseTemplate; // FO3/FONV
std::vector<FormId> mBodyParts; // FO3/FONV
ESM::FormId mBaseTemplate; // FO3/FONV
std::vector<ESM::FormId> mBodyParts; // FO3/FONV
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;

15
components/esm4/loaddial.cpp
View File

@ -34,8 +34,7 @@
void ESM4::Dialogue::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -50,19 +49,11 @@ void ESM4::Dialogue::load(ESM4::Reader& reader)
reader.getZString(mTopicName);
break;
case ESM4::SUB_QSTI:
{
FormId questId;
reader.getFormId(questId);
mQuests.push_back(questId);
reader.getFormId(mQuests.emplace_back());
break;
}
case ESM4::SUB_QSTR: // Seems never used in TES4
{
FormId questRem;
reader.getFormId(questRem);
mQuestsRemoved.push_back(questRem);
reader.getFormId(mQuestsRemoved.emplace_back());
break;
}
case ESM4::SUB_DATA:
{
if (subHdr.dataSize == 4) // TES5

10
components/esm4/loaddial.hpp
View File

@ -31,7 +31,8 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -40,12 +41,12 @@ namespace ESM4
struct Dialogue
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
std::vector<FormId> mQuests;
std::vector<FormId> mQuestsRemoved; // FONV only?
std::vector<ESM::FormId> mQuests;
std::vector<ESM::FormId> mQuestsRemoved; // FONV only?
std::string mTopicName;
std::string mTextDumb; // FIXME: temp name
@ -60,6 +61,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_DIAL4;
};
}

3
components/esm4/loaddobj.cpp
View File

@ -36,8 +36,7 @@
void ESM4::DefaultObj::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

74
components/esm4/loaddobj.hpp
View File

@ -32,7 +32,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -41,46 +42,46 @@ namespace ESM4
struct Defaults
{
FormId stimpack;
FormId superStimpack;
FormId radX;
FormId radAway;
FormId morphine;
FormId perkParalysis;
FormId playerFaction;
FormId mysteriousStrangerNPC;
FormId mysteriousStrangerFaction;
FormId defaultMusic;
FormId battleMusic;
FormId deathMusic;
FormId successMusic;
FormId levelUpMusic;
FormId playerVoiceMale;
FormId playerVoiceMaleChild;
FormId playerVoiceFemale;
FormId playerVoiceFemaleChild;
FormId eatPackageDefaultFood;
FormId everyActorAbility;
FormId drugWearsOffImageSpace;
ESM::FormId stimpack;
ESM::FormId superStimpack;
ESM::FormId radX;
ESM::FormId radAway;
ESM::FormId morphine;
ESM::FormId perkParalysis;
ESM::FormId playerFaction;
ESM::FormId mysteriousStrangerNPC;
ESM::FormId mysteriousStrangerFaction;
ESM::FormId defaultMusic;
ESM::FormId battleMusic;
ESM::FormId deathMusic;
ESM::FormId successMusic;
ESM::FormId levelUpMusic;
ESM::FormId playerVoiceMale;
ESM::FormId playerVoiceMaleChild;
ESM::FormId playerVoiceFemale;
ESM::FormId playerVoiceFemaleChild;
ESM::FormId eatPackageDefaultFood;
ESM::FormId everyActorAbility;
ESM::FormId drugWearsOffImageSpace;
// below FONV only
FormId doctorsBag;
FormId missFortuneNPC;
FormId missFortuneFaction;
FormId meltdownExplosion;
FormId unarmedForwardPA;
FormId unarmedBackwardPA;
FormId unarmedLeftPA;
FormId unarmedRightPA;
FormId unarmedCrouchPA;
FormId unarmedCounterPA;
FormId spotterEffect;
FormId itemDetectedEfect;
FormId cateyeMobileEffectNYI;
ESM::FormId doctorsBag;
ESM::FormId missFortuneNPC;
ESM::FormId missFortuneFaction;
ESM::FormId meltdownExplosion;
ESM::FormId unarmedForwardPA;
ESM::FormId unarmedBackwardPA;
ESM::FormId unarmedLeftPA;
ESM::FormId unarmedRightPA;
ESM::FormId unarmedCrouchPA;
ESM::FormId unarmedCounterPA;
ESM::FormId spotterEffect;
ESM::FormId itemDetectedEfect;
ESM::FormId cateyeMobileEffectNYI;
};
struct DefaultObj
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -91,6 +92,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_DOBJ4;
};
}

2
components/esm4/loaddoor.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Door::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

16
components/esm4/loaddoor.hpp
View File

@ -31,9 +31,7 @@
#include <string>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -50,7 +48,7 @@ namespace ESM4
Flag_MinimalUse = 0x08
};
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -60,11 +58,11 @@ namespace ESM4
float mBoundRadius;
std::uint8_t mDoorFlags;
FormId mScriptId;
FormId mOpenSound; // SNDR for TES5, SOUN for others
FormId mCloseSound; // SNDR for TES5, SOUN for others
FormId mLoopSound;
FormId mRandomTeleport;
ESM::FormId mScriptId;
ESM::FormId mOpenSound; // SNDR for TES5, SOUN for others
ESM::FormId mCloseSound; // SNDR for TES5, SOUN for others
ESM::FormId mLoopSound;
ESM::FormId mRandomTeleport;
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;

3
components/esm4/loadeyes.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Eyes::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadeyes.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -46,7 +47,7 @@ namespace ESM4
};
#pragma pack(pop)
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -59,6 +60,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_EYES4;
};
}

3
components/esm4/loadflor.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Flora::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

12
components/esm4/loadflor.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -57,7 +58,7 @@ namespace ESM4
};
#pragma pack(pop)
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -66,15 +67,16 @@ namespace ESM4
float mBoundRadius;
FormId mScriptId;
FormId mIngredient;
FormId mSound;
ESM::FormId mScriptId;
ESM::FormId mIngredient;
ESM::FormId mSound;
Production mPercentHarvest;
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_FLOR4;
};
}

9
components/esm4/loadflst.cpp
View File

@ -33,8 +33,7 @@
void ESM4::FormIdList::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -46,12 +45,8 @@ void ESM4::FormIdList::load(ESM4::Reader& reader)
reader.getZString(mEditorId);
break;
case ESM4::SUB_LNAM:
{
FormId formId;
reader.getFormId(formId);
mObjects.push_back(formId);
reader.getFormId(mObjects.emplace_back());
break;
}
default:
throw std::runtime_error("ESM4::FLST::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}

8
components/esm4/loadflst.hpp
View File

@ -31,7 +31,8 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -40,17 +41,18 @@ namespace ESM4
struct FormIdList
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
std::vector<FormId> mObjects;
std::vector<ESM::FormId> mObjects;
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_FLST4;
};
}

2
components/esm4/loadfurn.cpp
View File

@ -33,7 +33,7 @@
void ESM4::Furniture::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

8
components/esm4/loadfurn.hpp
View File

@ -31,9 +31,7 @@
#include <string>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include "formid.hpp"
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -42,7 +40,7 @@ namespace ESM4
struct Furniture
{
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -51,7 +49,7 @@ namespace ESM4
float mBoundRadius;
FormId mScriptId;
ESM::FormId mScriptId;
std::uint32_t mActiveMarkerFlags;
void load(ESM4::Reader& reader);

3
components/esm4/loadglob.cpp
View File

@ -33,8 +33,7 @@
void ESM4::GlobalVariable::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadglob.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -39,7 +40,7 @@ namespace ESM4
struct GlobalVariable
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -51,6 +52,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_GLOB4;
};
}

9
components/esm4/loadgmst.cpp
View File

@ -10,7 +10,7 @@ namespace ESM4
{
namespace
{
GameSetting::Data readData(FormId formId, std::string_view editorId, Reader& reader)
GameSetting::Data readData(ESM::FormId formId, std::string_view editorId, Reader& reader)
{
if (editorId.empty())
{
@ -53,8 +53,7 @@ namespace ESM4
void GameSetting::load(Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
@ -66,11 +65,11 @@ namespace ESM4
reader.getZString(mEditorId);
break;
case ESM4::SUB_DATA:
mData = readData(mFormId, mEditorId, reader);
mData = readData(mId, mEditorId, reader);
break;
default:
throw std::runtime_error(
"Unknown ESM4 GMST (" + mFormId.toString() + ") subrecord " + ESM::printName(subHdr.typeId));
"Unknown ESM4 GMST (" + mId.toString() + ") subrecord " + ESM::printName(subHdr.typeId));
}
}
}

6
components/esm4/loadgmst.hpp
View File

@ -5,7 +5,8 @@
#include <string>
#include <variant>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -15,12 +16,13 @@ namespace ESM4
{
using Data = std::variant<std::monostate, bool, float, std::int32_t, std::string>;
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
Data mData;
void load(Reader& reader);
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_GMST4;
};
}

3
components/esm4/loadgras.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Grass::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadgras.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -75,7 +76,7 @@ namespace ESM4
};
#pragma pack(pop)
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -89,6 +90,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_GRAS4;
};
}

27
components/esm4/loadgrup.hpp
View File

@ -30,6 +30,9 @@
#include <cstdint>
#include <vector>
#include <components/esm/formid.hpp>
#include <components/esm4/reader.hpp>
namespace ESM4
{
// http://www.uesp.net/wiki/Tes4Mod:Mod_File_Format#Hierarchical_Top_Groups
@ -76,14 +79,14 @@ namespace ESM4
//
struct WorldGroup
{
FormId mWorld; // WRLD record for this group
ESM::FormId mWorld; // WRLD record for this group
// occurs only after World Child (type 1)
// since GRUP label may not be reliable, need to keep the formid of the current WRLD in
// the reader's context
FormId mRoad;
ESM::FormId mRoad;
std::vector<FormId> mCells; // FIXME should this be CellGroup* instead?
std::vector<ESM::FormId> mCells; // FIXME should this be CellGroup* instead?
};
// http://www.uesp.net/wiki/Tes4Mod:Mod_File_Format/CELL
@ -99,7 +102,7 @@ namespace ESM4
// NOTE: There may be many CELL records in one subblock
struct CellGroup
{
FormId mCell; // CELL record for this cell group
ESM::FormId mCell; // CELL record for this cell group
int mCellModIndex; // from which file to get the CELL record (e.g. may have been updated)
// For retrieving parent group size (for lazy loading or skipping) and sub-block number / grid
@ -129,20 +132,20 @@ namespace ESM4
// cache (modindex adjusted) formId's of children
// FIXME: also need file index + file context of all those that has type 8 GRUP
GroupTypeHeader mHdrPersist;
std::vector<FormId> mPersistent; // REFR, ACHR, ACRE
std::vector<FormId> mdelPersistent;
std::vector<ESM::FormId> mPersistent; // REFR, ACHR, ACRE
std::vector<ESM::FormId> mdelPersistent;
// FIXME: also need file index + file context of all those that has type 10 GRUP
GroupTypeHeader mHdrVisDist;
std::vector<FormId> mVisibleDist; // REFR, ACHR, ACRE
std::vector<FormId> mdelVisibleDist;
std::vector<ESM::FormId> mVisibleDist; // REFR, ACHR, ACRE
std::vector<ESM::FormId> mdelVisibleDist;
// FIXME: also need file index + file context of all those that has type 9 GRUP
GroupTypeHeader mHdrTemp;
FormId mLand; // if present, assume only one LAND per exterior CELL
FormId mPgrd; // if present, seems to be the first record after LAND in Temp Cell Child GRUP
std::vector<FormId> mTemporary; // REFR, ACHR, ACRE
std::vector<FormId> mdelTemporary;
ESM::FormId mLand; // if present, assume only one LAND per exterior CELL
ESM::FormId mPgrd; // if present, seems to be the first record after LAND in Temp Cell Child GRUP
std::vector<ESM::FormId> mTemporary; // REFR, ACHR, ACRE
std::vector<ESM::FormId> mdelTemporary;
// need to keep modindex and context for lazy loading (of all the files that contribute
// to this group)

3
components/esm4/loadhair.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Hair::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadhair.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -46,7 +47,7 @@ namespace ESM4
};
#pragma pack(pop)
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -62,6 +63,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_HAIR4;
};
}

3
components/esm4/loadhdpt.cpp
View File

@ -35,8 +35,7 @@
void ESM4::HeadPart::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::optional<std::uint32_t> type;

10
components/esm4/loadhdpt.hpp
View File

@ -31,7 +31,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -40,7 +41,7 @@ namespace ESM4
struct HeadPart
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -49,15 +50,16 @@ namespace ESM4
std::uint8_t mData;
FormId mAdditionalPart;
ESM::FormId mAdditionalPart;
std::array<std::string, 3> mTriFile;
FormId mBaseTexture;
ESM::FormId mBaseTexture;
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_HDPT4;
};
}

3
components/esm4/loadidle.cpp
View File

@ -33,8 +33,7 @@
void ESM4::IdleAnimation::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

10
components/esm4/loadidle.hpp
View File

@ -30,7 +30,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -39,7 +40,7 @@ namespace ESM4
struct IdleAnimation
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -47,8 +48,8 @@ namespace ESM4
std::string mEvent;
std::string mModel;
FormId mParent; // IDLE or AACT
FormId mPrevious;
ESM::FormId mParent; // IDLE or AACT
ESM::FormId mPrevious;
float mBoundRadius;
@ -56,6 +57,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_IDLE4;
};
}

5
components/esm4/loadidlm.cpp
View File

@ -33,8 +33,7 @@
void ESM4::IdleMarker::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
@ -72,7 +71,7 @@ void ESM4::IdleMarker::load(ESM4::Reader& reader)
}
mIdleAnim.resize(mIdleCount);
for (FormId& value : mIdleAnim)
for (ESM::FormId& value : mIdleAnim)
reader.getFormId(value);
break;
}

8
components/esm4/loadidlm.hpp
View File

@ -31,7 +31,8 @@
#include <string>
#include <vector>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -40,7 +41,7 @@ namespace ESM4
struct IdleMarker
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -49,12 +50,13 @@ namespace ESM4
std::uint8_t mIdleFlags;
std::uint8_t mIdleCount;
float mIdleTimer;
std::vector<FormId> mIdleAnim;
std::vector<ESM::FormId> mIdleAnim;
void load(ESM4::Reader& reader);
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_IDLM4;
};
}

3
components/esm4/loadimod.cpp
View File

@ -35,8 +35,7 @@
void ESM4::ItemMod::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadimod.hpp
View File

@ -32,7 +32,8 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -41,7 +42,7 @@ namespace ESM4
struct ItemMod
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -50,6 +51,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_IMOD4;
};
}

7
components/esm4/loadinfo.cpp
View File

@ -29,16 +29,17 @@
#include <cstring>
#include <stdexcept>
#include <components/esm/refid.hpp>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::DialogInfo::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
mEditorId = formIdToString(mFormId); // FIXME: quick workaround to use existing code
mEditorId = ESM::RefId(mId).serializeText(); // FIXME: quick workaround to use existing code
static ScriptLocalVariableData localVar;
bool ignore = false;

12
components/esm4/loadinfo.hpp
View File

@ -30,8 +30,9 @@
#include <cstdint>
#include <string>
#include "formid.hpp"
#include "script.hpp" // TargetCondition
#include <components/esm/defs.hpp>
#include <components/esm/formid.hpp>
namespace ESM4
{
@ -54,13 +55,13 @@ namespace ESM4
struct DialogInfo
{
FormId mFormId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId; // FIXME: no such record for INFO, but keep here to avoid extra work for now
FormId mQuest;
FormId mSound; // unused?
ESM::FormId mQuest;
ESM::FormId mSound; // unused?
TargetResponseData mResponseData;
std::string mResponse;
@ -72,7 +73,7 @@ namespace ESM4
std::uint16_t mInfoFlags; // see above enum
TargetCondition mTargetCondition;
FormId mParam3; // TES5 only
ESM::FormId mParam3; // TES5 only
ScriptDefinition mScript; // FIXME: ignoring the second one after the NEXT sub-record
@ -80,6 +81,7 @@ namespace ESM4
// void save(ESM4::Writer& writer) const;
// void blank();
static constexpr ESM::RecNameInts sRecordId = ESM::RecNameInts::REC_INFO4;
};
}

2
components/esm4/loadingr.cpp
View File

@ -34,7 +34,7 @@
void ESM4::Ingredient::load(ESM4::Reader& reader)
{
mId = reader.getRefIdFromHeader();
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

6
components/esm4/loadingr.hpp
View File

@ -31,7 +31,7 @@
#include <vector>
#include <components/esm/defs.hpp>
#include <components/esm/refid.hpp>
#include <components/esm/formid.hpp>
#include "effect.hpp"
@ -56,7 +56,7 @@ namespace ESM4
};
#pragma pack(pop)
ESM::RefId mId; // from the header
ESM::FormId mId; // from the header
std::uint32_t mFlags; // from the header, see enum type RecordFlag for details
std::string mEditorId;
@ -67,7 +67,7 @@ namespace ESM4
float mBoundRadius;
std::vector<std::string> mScriptEffect; // FIXME: prob. should be in a struct
FormId mScriptId;
ESM::FormId mScriptId;
ScriptEffect mEffect;
ENIT mEnchantment;

3
components/esm4/loadkeym.cpp
View File

@ -33,8 +33,7 @@
void ESM4::Key::load(ESM4::Reader& reader)
{
mFormId = reader.hdr().record.getFormId();
reader.adjustFormId(mFormId);
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())

Some files were not shown because too many files have changed in this diff Show More